kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-04-18 13:36:49 +02:00
Code Issues Packages Projects Releases Wiki Activity

[BOT] update dependencies

Browse Source
This commit is contained in:
kbJeff-8
2026-03-22 01:03:14 +00:00
committed by kbz_8
parent 002c35ccdb
commit 2751206578
12 changed files with 1992 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
third_party/vulkan/vulkan.cppm vendored
View File

@@ -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;

127
third_party/vulkan/vulkan.hpp vendored
View File

@@ -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<PhysicalDeviceShaderConstantDataFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderConstantDataFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_abort ===
template <>
struct StructExtends<PhysicalDeviceShaderAbortFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAbortFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceFaultShaderAbortMessageInfoKHR, DeviceFaultDebugInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAbortPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_image_atomic_int64 ===
template <>
struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>
@@ -20890,6 +20975,34 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_device_fault ===
template <>
struct StructExtends<PhysicalDeviceFaultFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFaultFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFaultPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_maintenance8 ===
template <>
struct StructExtends<MemoryBarrierAccessFlags3KHR, SubpassDependency2>
@@ -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" ) );

219
third_party/vulkan/vulkan_core.h vendored
View File

@@ -66,7 +66,7 @@ extern "C" {
//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 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);

86
third_party/vulkan/vulkan_enums.hpp vendored
View File

@@ -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<DeviceFaultFlagBitsKHR>;
template <>
struct FlagTraits<DeviceFaultFlagBitsKHR>
{
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

50
third_party/vulkan/vulkan_extension_inspection.hpp vendored
View File

@@ -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" ) ||

94
third_party/vulkan/vulkan_funcs.hpp vendored
View File

@@ -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 <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::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<Result>(
d.vkGetDeviceFaultReportsKHR( static_cast<VkDevice>( m_device ), timeout, pFaultCounts, reinterpret_cast<VkDeviceFaultInfoKHR *>( 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 <typename DeviceFaultInfoKHRAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename DeviceFaultInfoKHRAllocator::value_type, DeviceFaultInfoKHR>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator>> 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 <vkGetDeviceFaultReportsKHR> requires <VK_KHR_device_fault>" );
# endif
std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator> faultInfo;
uint32_t faultCounts;
Result result;
do
{
result = static_cast<Result>( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, nullptr ) );
if ( ( result == Result::eSuccess ) && faultCounts )
{
faultInfo.resize( faultCounts );
result =
static_cast<Result>( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, reinterpret_cast<VkDeviceFaultInfoKHR *>( 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 <typename DeviceFaultInfoKHRAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename DeviceFaultInfoKHRAllocator::value_type, DeviceFaultInfoKHR>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator>> 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 <vkGetDeviceFaultReportsKHR> requires <VK_KHR_device_fault>" );
# endif
std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator> faultInfo( deviceFaultInfoKHRAllocator );
uint32_t faultCounts;
Result result;
do
{
result = static_cast<Result>( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, nullptr ) );
if ( ( result == Result::eSuccess ) && faultCounts )
{
faultInfo.resize( faultCounts );
result =
static_cast<Result>( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, reinterpret_cast<VkDeviceFaultInfoKHR *>( 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 <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultDebugInfoKHR ), bool>::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<Result>(
d.vkGetDeviceFaultDebugInfoKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultDebugInfoKHR *>( pDebugInfo ) ) );
}
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===

54
third_party/vulkan/vulkan_handles.hpp vendored
View File

@@ -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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::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 DeviceFaultInfoKHRAllocator = std::allocator<DeviceFaultInfoKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename DeviceFaultInfoKHRAllocator::value_type, DeviceFaultInfoKHR>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::type = true>
VULKAN_HPP_NODISCARD ResultValue<std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator>>
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 DeviceFaultInfoKHRAllocator = std::allocator<DeviceFaultInfoKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename DeviceFaultInfoKHRAllocator::value_type, DeviceFaultInfoKHR>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultReportsKHR ), bool>::type = true>
VULKAN_HPP_NODISCARD ResultValue<std::vector<DeviceFaultInfoKHR, DeviceFaultInfoKHRAllocator>> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkGetDeviceFaultDebugInfoKHR ), bool>::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 ===

165
third_party/vulkan/vulkan_hash.hpp vendored
View File

@@ -4950,14 +4950,14 @@ VULKAN_HPP_EXPORT namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>
struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoKHR>
{
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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>
struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultDebugInfoKHR>
{
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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoKHR>
{
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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>
struct hash<VULKAN_HPP_NAMESPACE::DeviceFaultInfoKHR>
{
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<VULKAN_HPP_NAMESPACE::DeviceFaultShaderAbortMessageInfoKHR>
{
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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultPropertiesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
{
@@ -14235,6 +14313,33 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortFeaturesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortPropertiesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>
{
@@ -14344,6 +14449,20 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderConstantDataFeaturesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM>
{

55
third_party/vulkan/vulkan_raii.hpp vendored
View File

@@ -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<AllocationCallbacks const> 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<std::vector<DeviceFaultInfoKHR>> 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<VkWriteIndirectExecutionSetShaderEXT const *>( 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<std::vector<DeviceFaultInfoKHR>> Device::getFaultReportsKHR( uint64_t timeout ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultReportsKHR && "Function <vkGetDeviceFaultReportsKHR> requires <VK_KHR_device_fault>" );
std::vector<DeviceFaultInfoKHR> faultInfo;
uint32_t faultCounts;
Result result;
do
{
result = static_cast<Result>( getDispatcher()->vkGetDeviceFaultReportsKHR( static_cast<VkDevice>( m_device ), timeout, &faultCounts, nullptr ) );
if ( ( result == Result::eSuccess ) && faultCounts )
{
faultInfo.resize( faultCounts );
result = static_cast<Result>( getDispatcher()->vkGetDeviceFaultReportsKHR(
static_cast<VkDevice>( m_device ), timeout, &faultCounts, reinterpret_cast<VkDeviceFaultInfoKHR *>( 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 <vkGetDeviceFaultDebugInfoKHR> requires <VK_KHR_device_fault>" );
return static_cast<Result>(
getDispatcher()->vkGetDeviceFaultDebugInfoKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultDebugInfoKHR *>( pDebugInfo ) ) );
}
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===

96
third_party/vulkan/vulkan_static_assertions.hpp vendored
View File

@@ -4881,6 +4881,39 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderConstantDataFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderConstantDataFeaturesKHR>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortFeaturesKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultShaderAbortMessageInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultShaderAbortMessageInfoKHR>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortPropertiesKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFa
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>::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<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT>::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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT>::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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT>::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<VULKAN_HPP_NAMESPACE::WriteInd
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesKHR>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultPropertiesKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultInfoKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultDebugInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultDebugInfoKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoKHR>::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<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneKHR>::value,
"DeviceFaultVendorBinaryHeaderVersionOneKHR is not nothrow_move_constructible!" );
//=== VK_KHR_maintenance8 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ),

1223
third_party/vulkan/vulkan_structs.hpp vendored
View File

File diff suppressed because it is too large Load Diff

99
third_party/vulkan/vulkan_to_string.hpp vendored
View File

@@ -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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( value ) ) + " )";
}
}
//=== VK_KHR_maintenance8 ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits3KHR value )