kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-06-13 19:34:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

[BOT] update dependencies

Browse Source
This commit is contained in:
kbJeff-8
2025-12-21 00:51:03 +00:00
committed by kbz_8
parent cf84449dee
commit c251fb81e3
14 changed files with 1683 additions and 1036 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/vulkan/vulkan.cppm
Vendored
+25 -36
View File
@@ -1048,12 +1048,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
using VULKAN_HPP_NAMESPACE::SwapchainImageUsageFlagBitsOHOS;
using VULKAN_HPP_NAMESPACE::SwapchainImageUsageFlagsOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_ARM_performance_counters_by_region ===
using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM;
using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM;
@@ -2165,6 +2159,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorExtensionName;
using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorSpecVersion;
//=== VK_EXT_texture_compression_astc_3d ===
using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DExtensionName;
using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DSpecVersion;
//=== VK_GOOGLE_user_type ===
using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeExtensionName;
using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeSpecVersion;
@@ -2927,12 +2925,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::OHOSSurfaceSpecVersion;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
using VULKAN_HPP_NAMESPACE::OHOSNativeBufferExtensionName;
using VULKAN_HPP_NAMESPACE::OHOSNativeBufferSpecVersion;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
@@ -3010,6 +3002,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion;
//=== VK_EXT_shader_long_vector ===
using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorSpecVersion;
//=== VK_SEC_pipeline_cache_incremental_mode ===
using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeExtensionName;
using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeSpecVersion;
@@ -4373,6 +4369,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT;
using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT;
//=== VK_EXT_texture_compression_astc_3d ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
//=== VK_KHR_pipeline_library ===
using VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR;
@@ -5251,13 +5250,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
using VULKAN_HPP_NAMESPACE::NativeBufferOHOS;
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS;
using VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
@@ -5347,6 +5339,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR;
using VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR;
//=== VK_EXT_shader_long_vector ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT;
//=== VK_SEC_pipeline_cache_incremental_mode ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
@@ -7933,6 +7929,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>;
//=== VK_EXT_texture_compression_astc_3d ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>;
//=== VK_KHR_pipeline_library ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>;
@@ -9331,16 +9331,6 @@ export namespace std
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS>;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>;
@@ -9463,6 +9453,12 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>;
//=== VK_EXT_shader_long_vector ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT>;
//=== VK_SEC_pipeline_cache_incremental_mode ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>;
@@ -10662,13 +10658,6 @@ export
using ::PFN_vkCreateSurfaceOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
using ::PFN_vkAcquireImageOHOS;
using ::PFN_vkGetSwapchainGrallocUsageOHOS;
using ::PFN_vkQueueSignalReleaseImageOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
using ::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
third_party/vulkan/vulkan.hpp
Vendored
+63 -93
View File
@@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 336, "Wrong VK_HEADER_VERSION!" );
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 337, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@@ -6581,27 +6581,6 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
VkResult
vkGetSwapchainGrallocUsageOHOS( VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t * grallocUsage ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSwapchainGrallocUsageOHOS( device, format, imageUsage, grallocUsage );
}
VkResult vkAcquireImageOHOS( VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireImageOHOS( device, image, nativeFenceFd, semaphore, fence );
}
VkResult vkQueueSignalReleaseImageOHOS(
VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore * pWaitSemaphores, VkImage image, int32_t * pNativeFenceFd ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueSignalReleaseImageOHOS( queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd );
}
# endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
@@ -6697,9 +6676,10 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks;
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
namespace detail
{
template <typename OwnerType, typename Dispatch>
@@ -8837,6 +8817,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME;
//=== VK_EXT_texture_compression_astc_3d ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME;
//=== VK_GOOGLE_user_type ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeSpecVersion = VK_GOOGLE_USER_TYPE_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeExtensionName = VK_GOOGLE_USER_TYPE_EXTENSION_NAME;
@@ -9591,12 +9575,6 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceExtensionName = VK_OHOS_SURFACE_EXTENSION_NAME;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto OHOSNativeBufferSpecVersion = VK_OHOS_NATIVE_BUFFER_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto OHOSNativeBufferExtensionName = VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME;
@@ -9673,6 +9651,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME;
//=== VK_EXT_shader_long_vector ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorSpecVersion = VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorExtensionName = VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME;
//=== VK_SEC_pipeline_cache_incremental_mode ===
VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeSpecVersion = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeExtensionName = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME;
@@ -14550,6 +14532,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_texture_compression_astc_3d ===
template <>
struct StructExtends<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_pipeline_library ===
template <>
struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo>
@@ -19492,45 +19493,6 @@ namespace VULKAN_HPP_NAMESPACE
};
};
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
template <>
struct StructExtends<NativeBufferOHOS, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<NativeBufferOHOS, BindImageMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainImageCreateInfoOHOS, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentationPropertiesOHOS, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
template <>
struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, PhysicalDeviceFeatures2>
@@ -20039,6 +20001,34 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_shader_long_vector ===
template <>
struct StructExtends<PhysicalDeviceShaderLongVectorFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderLongVectorFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderLongVectorPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_SEC_pipeline_cache_incremental_mode ===
template <>
struct StructExtends<PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, PhysicalDeviceFeatures2>
@@ -20136,6 +20126,11 @@ namespace VULKAN_HPP_NAMESPACE
{
m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
}
// for Homebrew installations on Apple Silicon
if ( !m_library )
{
m_library = dlopen( "/opt/homebrew/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
}
if ( !m_library )
{
m_library = dlopen( "libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL );
@@ -21490,17 +21485,6 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkCreateSurfaceOHOS_placeholder = 0;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
PFN_vkGetSwapchainGrallocUsageOHOS vkGetSwapchainGrallocUsageOHOS = 0;
PFN_vkAcquireImageOHOS vkAcquireImageOHOS = 0;
PFN_vkQueueSignalReleaseImageOHOS vkQueueSignalReleaseImageOHOS = 0;
#else
PFN_dummy vkGetSwapchainGrallocUsageOHOS_placeholder = 0;
PFN_dummy vkAcquireImageOHOS_placeholder = 0;
PFN_dummy vkQueueSignalReleaseImageOHOS_placeholder = 0;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
@@ -23148,13 +23132,6 @@ namespace VULKAN_HPP_NAMESPACE
vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) );
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
vkGetSwapchainGrallocUsageOHOS = PFN_vkGetSwapchainGrallocUsageOHOS( vkGetInstanceProcAddr( instance, "vkGetSwapchainGrallocUsageOHOS" ) );
vkAcquireImageOHOS = PFN_vkAcquireImageOHOS( vkGetInstanceProcAddr( instance, "vkAcquireImageOHOS" ) );
vkQueueSignalReleaseImageOHOS = PFN_vkQueueSignalReleaseImageOHOS( vkGetInstanceProcAddr( instance, "vkQueueSignalReleaseImageOHOS" ) );
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
@@ -24420,13 +24397,6 @@ namespace VULKAN_HPP_NAMESPACE
vkUpdateIndirectExecutionSetShaderEXT =
PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) );
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
vkGetSwapchainGrallocUsageOHOS = PFN_vkGetSwapchainGrallocUsageOHOS( vkGetDeviceProcAddr( device, "vkGetSwapchainGrallocUsageOHOS" ) );
vkAcquireImageOHOS = PFN_vkAcquireImageOHOS( vkGetDeviceProcAddr( device, "vkAcquireImageOHOS" ) );
vkQueueSignalReleaseImageOHOS = PFN_vkQueueSignalReleaseImageOHOS( vkGetDeviceProcAddr( device, "vkQueueSignalReleaseImageOHOS" ) );
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
third_party/vulkan/vulkan_core.h
Vendored
+64 -4
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 336
#define VK_HEADER_VERSION 337
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -841,6 +841,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT = 1000288000,
VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001,
@@ -1334,9 +1335,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002,
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003,
VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS = 1000685000,
VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS = 1000453001,
VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS = 1000453002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS = 1000453003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000,
VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000,
@@ -1381,6 +1379,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002,
VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003,
VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT = 1000635000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT = 1000635001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000,
VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV = 1000645000,
@@ -2034,6 +2034,36 @@ typedef enum VkFormat {
VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT = 1000288000,
VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT = 1000288001,
VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT = 1000288002,
VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT = 1000288003,
VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT = 1000288004,
VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT = 1000288005,
VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT = 1000288006,
VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT = 1000288007,
VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT = 1000288008,
VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT = 1000288009,
VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT = 1000288010,
VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT = 1000288011,
VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT = 1000288012,
VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT = 1000288013,
VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT = 1000288014,
VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT = 1000288015,
VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT = 1000288016,
VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT = 1000288017,
VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT = 1000288018,
VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT = 1000288019,
VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT = 1000288020,
VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT = 1000288021,
VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT = 1000288022,
VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT = 1000288023,
VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT = 1000288024,
VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT = 1000288025,
VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT = 1000288026,
VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT = 1000288027,
VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT = 1000288028,
VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT = 1000288029,
VK_FORMAT_R8_BOOL_ARM = 1000460000,
VK_FORMAT_R16G16_SFIXED5_NV = 1000464000,
VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000,
@@ -18397,6 +18427,18 @@ typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
// VK_EXT_texture_compression_astc_3d is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_texture_compression_astc_3d 1
#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION 1
#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME "VK_EXT_texture_compression_astc_3d"
typedef struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 textureCompressionASTC_3D;
} VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
// VK_GOOGLE_user_type is a preprocessor guard. Do not pass it to API calls.
#define VK_GOOGLE_user_type 1
#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1
@@ -24169,6 +24211,24 @@ typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
// VK_EXT_shader_long_vector is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_shader_long_vector 1
#define VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION 1
#define VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME "VK_EXT_shader_long_vector"
typedef struct VkPhysicalDeviceShaderLongVectorFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 longVector;
} VkPhysicalDeviceShaderLongVectorFeaturesEXT;
typedef struct VkPhysicalDeviceShaderLongVectorPropertiesEXT {
VkStructureType sType;
void* pNext;
uint32_t maxVectorComponents;
} VkPhysicalDeviceShaderLongVectorPropertiesEXT;
// VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls.
#define VK_SEC_pipeline_cache_incremental_mode 1
#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1
third_party/vulkan/vulkan_enums.hpp
Vendored
+34 -26
View File
@@ -1189,6 +1189,7 @@ namespace VULKAN_HPP_NAMESPACE
eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT,
ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
ePhysicalDevicePresentBarrierFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV,
eSurfaceCapabilitiesPresentBarrierNV = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV,
@@ -1700,10 +1701,7 @@ namespace VULKAN_HPP_NAMESPACE
eVideoDecodeH265InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR,
eVideoDecodeAv1InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR,
#if defined( VK_USE_PLATFORM_OHOS )
eSurfaceCreateInfoOHOS = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS,
eNativeBufferOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS,
eSwapchainImageCreateInfoOHOS = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS,
ePhysicalDevicePresentationPropertiesOHOS = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS,
eSurfaceCreateInfoOHOS = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS,
#endif /*VK_USE_PLATFORM_OHOS*/
ePhysicalDeviceHdrVividFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI,
eHdrVividDynamicMetadataHUAWEI = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI,
@@ -1757,6 +1755,8 @@ namespace VULKAN_HPP_NAMESPACE
eRenderingEndInfoKHR = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR,
eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT,
eResolveImageModeInfoKHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR,
ePhysicalDeviceShaderLongVectorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT,
ePhysicalDeviceShaderLongVectorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT,
ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC,
ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT,
eComputeOccupancyPriorityParametersNV = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV,
@@ -2154,6 +2154,36 @@ namespace VULKAN_HPP_NAMESPACE
ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
eAstc3x3x3UnormBlockEXT = VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT,
eAstc3x3x3SrgbBlockEXT = VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT,
eAstc3x3x3SfloatBlockEXT = VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT,
eAstc4x3x3UnormBlockEXT = VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT,
eAstc4x3x3SrgbBlockEXT = VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT,
eAstc4x3x3SfloatBlockEXT = VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT,
eAstc4x4x3UnormBlockEXT = VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT,
eAstc4x4x3SrgbBlockEXT = VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT,
eAstc4x4x3SfloatBlockEXT = VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT,
eAstc4x4x4UnormBlockEXT = VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT,
eAstc4x4x4SrgbBlockEXT = VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT,
eAstc4x4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT,
eAstc5x4x4UnormBlockEXT = VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT,
eAstc5x4x4SrgbBlockEXT = VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT,
eAstc5x4x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT,
eAstc5x5x4UnormBlockEXT = VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT,
eAstc5x5x4SrgbBlockEXT = VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT,
eAstc5x5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT,
eAstc5x5x5UnormBlockEXT = VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT,
eAstc5x5x5SrgbBlockEXT = VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT,
eAstc5x5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT,
eAstc6x5x5UnormBlockEXT = VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT,
eAstc6x5x5SrgbBlockEXT = VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT,
eAstc6x5x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT,
eAstc6x6x5UnormBlockEXT = VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT,
eAstc6x6x5SrgbBlockEXT = VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT,
eAstc6x6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT,
eAstc6x6x6UnormBlockEXT = VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT,
eAstc6x6x6SrgbBlockEXT = VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT,
eAstc6x6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT,
eR8BoolARM = VK_FORMAT_R8_BOOL_ARM,
eR16G16Sfixed5NV = VK_FORMAT_R16G16_SFIXED5_NV,
eR16G16S105NV = VK_FORMAT_R16G16_S10_5_NV,
@@ -9466,28 +9496,6 @@ namespace VULKAN_HPP_NAMESPACE
};
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper class for enum VkSwapchainImageUsageFlagBitsOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagBitsOHOS.html
enum class SwapchainImageUsageFlagBitsOHOS : VkSwapchainImageUsageFlagsOHOS
{
eShared = VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS
};
// wrapper using for bitmask VkSwapchainImageUsageFlagsOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageUsageFlagsOHOS.html
using SwapchainImageUsageFlagsOHOS = Flags<SwapchainImageUsageFlagBitsOHOS>;
template <>
struct FlagTraits<SwapchainImageUsageFlagBitsOHOS>
{
using WrappedType = VkSwapchainImageUsageFlagBitsOHOS;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainImageUsageFlagsOHOS allFlags = SwapchainImageUsageFlagBitsOHOS::eShared;
};
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_ARM_performance_counters_by_region ===
enum class PerformanceCounterDescriptionFlagBitsARM : VkPerformanceCounterDescriptionFlagsARM
third_party/vulkan/vulkan_extension_inspection.hpp
Vendored
+16 -13
View File
@@ -298,6 +298,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_device_memory_report",
"VK_EXT_robustness2",
"VK_EXT_custom_border_color",
"VK_EXT_texture_compression_astc_3d",
"VK_GOOGLE_user_type",
"VK_KHR_pipeline_library",
"VK_NV_present_barrier",
@@ -488,9 +489,6 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_depth_clamp_control",
"VK_KHR_maintenance9",
"VK_KHR_video_maintenance2",
#if defined( VK_USE_PLATFORM_OHOS )
"VK_OHOS_native_buffer",
#endif /*VK_USE_PLATFORM_OHOS*/
"VK_HUAWEI_hdr_vivid",
"VK_NV_cooperative_matrix2",
"VK_ARM_pipeline_opacity_micromap",
@@ -513,6 +511,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_custom_resolve",
"VK_QCOM_data_graph_model",
"VK_KHR_maintenance10",
"VK_EXT_shader_long_vector",
"VK_SEC_pipeline_cache_incremental_mode",
"VK_EXT_shader_uniform_buffer_unsized_array",
"VK_NV_compute_occupancy_priority" };
@@ -1747,6 +1746,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_texture_compression_astc_3d",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_present_barrier",
{ { "VK_VERSION_1_0",
{ {
@@ -3019,6 +3024,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_shader_long_vector", { { "VK_VERSION_1_2", { {} } } } },
{ "VK_SEC_pipeline_cache_incremental_mode",
{ { "VK_VERSION_1_0",
{ {
@@ -3878,9 +3884,9 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_inherited_viewport_scissor" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) ||
( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_QCOM_render_pass_transform" ) ||
( extension == "VK_EXT_depth_bias_control" ) || ( extension == "VK_EXT_device_memory_report" ) || ( extension == "VK_EXT_robustness2" ) ||
( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_GOOGLE_user_type" ) || ( extension == "VK_KHR_pipeline_library" ) ||
( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_KHR_present_id" ) ||
( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) ||
( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_EXT_texture_compression_astc_3d" ) || ( extension == "VK_GOOGLE_user_type" ) ||
( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) ||
( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) ||
( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) ||
( extension == "VK_QCOM_render_pass_store_ops" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -3977,11 +3983,8 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) ||
( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" )
#if defined( VK_USE_PLATFORM_OHOS )
|| ( extension == "VK_OHOS_native_buffer" )
#endif /*VK_USE_PLATFORM_OHOS*/
|| ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
@@ -3994,8 +3997,8 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) ||
( extension == "VK_NV_compute_occupancy_priority" );
( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
third_party/vulkan/vulkan_format_traits.hpp
Vendored
+931 -1
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_funcs.hpp
Vendored
-100
View File
@@ -31880,106 +31880,6 @@ namespace VULKAN_HPP_NAMESPACE
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
Device::getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, uint64_t * grallocUsage, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetSwapchainGrallocUsageOHOS(
static_cast<VkDevice>( m_device ), static_cast<VkFormat>( format ), static_cast<VkImageUsageFlags>( imageUsage ), grallocUsage ) );
}
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type
Device::getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetSwapchainGrallocUsageOHOS && "Function <vkGetSwapchainGrallocUsageOHOS> requires <VK_OHOS_native_buffer>" );
# endif
uint64_t grallocUsage;
Result result = static_cast<Result>(
d.vkGetSwapchainGrallocUsageOHOS( m_device, static_cast<VkFormat>( format ), static_cast<VkImageUsageFlags>( imageUsage ), &grallocUsage ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainGrallocUsageOHOS" );
return detail::createResultValueType( result, std::move( grallocUsage ) );
}
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
Device::acquireImageOHOS( Image image, int32_t nativeFenceFd, Semaphore semaphore, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkAcquireImageOHOS(
static_cast<VkDevice>( m_device ), static_cast<VkImage>( image ), nativeFenceFd, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ) ) );
}
# else
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::acquireImageOHOS( Image image, int32_t nativeFenceFd, Semaphore semaphore, Fence fence, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkAcquireImageOHOS && "Function <vkAcquireImageOHOS> requires <VK_OHOS_native_buffer>" );
# endif
Result result = static_cast<Result>(
d.vkAcquireImageOHOS( m_device, static_cast<VkImage>( image ), nativeFenceFd, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireImageOHOS" );
return detail::createResultValueType( result );
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::signalReleaseImageOHOS(
uint32_t waitSemaphoreCount, const Semaphore * pWaitSemaphores, Image image, int32_t * pNativeFenceFd, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkQueueSignalReleaseImageOHOS( static_cast<VkQueue>( m_queue ),
waitSemaphoreCount,
reinterpret_cast<const VkSemaphore *>( pWaitSemaphores ),
static_cast<VkImage>( image ),
pNativeFenceFd ) );
}
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
template <typename Dispatch, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int32_t>::type
Queue::signalReleaseImageOHOS( ArrayProxy<const Semaphore> const & waitSemaphores, Image image, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkQueueSignalReleaseImageOHOS && "Function <vkQueueSignalReleaseImageOHOS> requires <VK_OHOS_native_buffer>" );
# endif
int32_t nativeFenceFd;
Result result = static_cast<Result>( d.vkQueueSignalReleaseImageOHOS(
m_queue, waitSemaphores.size(), reinterpret_cast<const VkSemaphore *>( waitSemaphores.data() ), static_cast<VkImage>( image ), &nativeFenceFd ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::signalReleaseImageOHOS" );
return detail::createResultValueType( result, std::move( nativeFenceFd ) );
}
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
// wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
third_party/vulkan/vulkan_handles.hpp
Vendored
+99 -158
View File
@@ -1308,6 +1308,9 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceCustomBorderColorPropertiesEXT;
struct PhysicalDeviceCustomBorderColorFeaturesEXT;
//=== VK_EXT_texture_compression_astc_3d ===
struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
//=== VK_KHR_pipeline_library ===
struct PipelineLibraryCreateInfoKHR;
@@ -2186,13 +2189,6 @@ namespace VULKAN_HPP_NAMESPACE
struct SurfaceCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
struct NativeBufferOHOS;
struct SwapchainImageCreateInfoOHOS;
struct PhysicalDevicePresentationPropertiesOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
struct PhysicalDeviceHdrVividFeaturesHUAWEI;
struct HdrVividDynamicMetadataHUAWEI;
@@ -2282,6 +2278,10 @@ namespace VULKAN_HPP_NAMESPACE
struct RenderingAttachmentFlagsInfoKHR;
struct ResolveImageModeInfoKHR;
//=== VK_EXT_shader_long_vector ===
struct PhysicalDeviceShaderLongVectorFeaturesEXT;
struct PhysicalDeviceShaderLongVectorPropertiesEXT;
//=== VK_SEC_pipeline_cache_incremental_mode ===
struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
@@ -3406,98 +3406,6 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
// wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html
class Image
{
public:
using CType = VkImage;
using NativeType = VkImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage;
public:
Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
Image( Image const & rhs ) = default;
Image & operator=( Image const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Image( Image && rhs ) = default;
Image & operator=( Image && rhs ) = default;
#else
Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {}
Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
{
m_image = exchange( rhs.m_image, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
{
m_image = image;
return *this;
}
#endif
Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_image = {};
return *this;
}
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
{
return m_image;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_image != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_image == VK_NULL_HANDLE;
}
private:
VkImage m_image = {};
};
template <>
struct CppType<ObjectType, ObjectType::eImage>
{
using Type = Image;
};
template <>
struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImage>
{
using Type = Image;
};
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
template <>
struct CppType<VkImage, VK_NULL_HANDLE>
{
using Type = Image;
};
#endif
template <>
struct isVulkanHandleType<Image>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
// wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html
class Semaphore
{
@@ -4413,6 +4321,98 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
// wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html
class Image
{
public:
using CType = VkImage;
using NativeType = VkImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage;
public:
Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue
Image( Image const & rhs ) = default;
Image & operator=( Image const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Image( Image && rhs ) = default;
Image & operator=( Image && rhs ) = default;
#else
Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {}
Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
{
m_image = exchange( rhs.m_image, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
{
m_image = image;
return *this;
}
#endif
Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_image = {};
return *this;
}
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
{
return m_image;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_image != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_image == VK_NULL_HANDLE;
}
private:
VkImage m_image = {};
};
template <>
struct CppType<ObjectType, ObjectType::eImage>
{
using Type = Image;
};
template <>
struct CppType<DebugReportObjectTypeEXT, DebugReportObjectTypeEXT::eImage>
{
using Type = Image;
};
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
template <>
struct CppType<VkImage, VK_NULL_HANDLE>
{
using Type = Image;
};
#endif
template <>
struct isVulkanHandleType<Image>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
// wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html
class AccelerationStructureNV
{
@@ -11081,27 +11081,6 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD Result signalReleaseImageOHOS( uint32_t waitSemaphoreCount,
const Semaphore * pWaitSemaphores,
Image image,
int32_t * pNativeFenceFd,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<int32_t>::type signalReleaseImageOHOS( ArrayProxy<const Semaphore> const & waitSemaphores,
Image image,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_OHOS*/
operator VkQueue() const VULKAN_HPP_NOEXCEPT
{
return m_queue;
@@ -18668,44 +18647,6 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD Result getSwapchainGrallocUsageOHOS( Format format,
ImageUsageFlags imageUsage,
uint64_t * grallocUsage,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD Result acquireImageOHOS( Image image,
int32_t nativeFenceFd,
Semaphore semaphore,
Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# else
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<detail::isDispatchLoader<Dispatch>::value, bool>::type = true>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireImageOHOS( Image image,
int32_t nativeFenceFd,
Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
third_party/vulkan/vulkan_hash.hpp
Vendored
+42 -46
View File
@@ -8598,21 +8598,6 @@ namespace std
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferOHOS const & nativeBufferOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.handle );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS>
@@ -13017,22 +13002,6 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS const & physicalDevicePresentationPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sharedImage );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
{
@@ -14075,6 +14044,34 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT const & physicalDeviceShaderLongVectorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.longVector );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT const & physicalDeviceShaderLongVectorPropertiesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.maxVectorComponents );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>
{
@@ -14595,6 +14592,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & physicalDeviceTextureCompressionASTC3DFeaturesEXT )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.textureCompressionASTC_3D );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures>
{
@@ -18599,21 +18610,6 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS const & swapchainImageCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.usage );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
{
third_party/vulkan/vulkan_ohos.h
Vendored
-62
View File
@@ -113,68 +113,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(
#endif
#endif
// VK_OHOS_native_buffer is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_native_buffer 1
struct OHBufferHandle;
#define VK_OHOS_NATIVE_BUFFER_SPEC_VERSION 1
#define VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME "VK_OHOS_native_buffer"
typedef enum VkSwapchainImageUsageFlagBitsOHOS {
VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS = 0x00000001,
VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_OHOS = 0x7FFFFFFF
} VkSwapchainImageUsageFlagBitsOHOS;
typedef VkFlags VkSwapchainImageUsageFlagsOHOS;
typedef struct VkNativeBufferOHOS {
VkStructureType sType;
const void* pNext;
struct OHBufferHandle* handle;
} VkNativeBufferOHOS;
typedef struct VkSwapchainImageCreateInfoOHOS {
VkStructureType sType;
const void* pNext;
VkSwapchainImageUsageFlagsOHOS usage;
} VkSwapchainImageCreateInfoOHOS;
typedef struct VkPhysicalDevicePresentationPropertiesOHOS {
VkStructureType sType;
void* pNext;
VkBool32 sharedImage;
} VkPhysicalDevicePresentationPropertiesOHOS;
typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageOHOS)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage);
typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageOHOS)(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageOHOS)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageOHOS(
VkDevice device,
VkFormat format,
VkImageUsageFlags imageUsage,
uint64_t* grallocUsage);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageOHOS(
VkDevice device,
VkImage image,
int32_t nativeFenceFd,
VkSemaphore semaphore,
VkFence fence);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageOHOS(
VkQueue queue,
uint32_t waitSemaphoreCount,
const VkSemaphore* pWaitSemaphores,
VkImage image,
int32_t* pNativeFenceFd);
#endif
#endif
#ifdef __cplusplus
}
#endif
third_party/vulkan/vulkan_raii.hpp
Vendored
-97
View File
@@ -1938,13 +1938,6 @@ namespace VULKAN_HPP_NAMESPACE
vkUpdateIndirectExecutionSetShaderEXT =
PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) );
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
vkGetSwapchainGrallocUsageOHOS = PFN_vkGetSwapchainGrallocUsageOHOS( vkGetDeviceProcAddr( device, "vkGetSwapchainGrallocUsageOHOS" ) );
vkAcquireImageOHOS = PFN_vkAcquireImageOHOS( vkGetDeviceProcAddr( device, "vkAcquireImageOHOS" ) );
vkQueueSignalReleaseImageOHOS = PFN_vkQueueSignalReleaseImageOHOS( vkGetDeviceProcAddr( device, "vkQueueSignalReleaseImageOHOS" ) );
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
@@ -2968,17 +2961,6 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0;
PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0;
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
PFN_vkGetSwapchainGrallocUsageOHOS vkGetSwapchainGrallocUsageOHOS = 0;
PFN_vkAcquireImageOHOS vkAcquireImageOHOS = 0;
PFN_vkQueueSignalReleaseImageOHOS vkQueueSignalReleaseImageOHOS = 0;
# else
PFN_dummy vkGetSwapchainGrallocUsageOHOS_placeholder = 0;
PFN_dummy vkAcquireImageOHOS_placeholder = 0;
PFN_dummy vkQueueSignalReleaseImageOHOS_placeholder = 0;
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0;
@@ -5746,14 +5728,6 @@ namespace VULKAN_HPP_NAMESPACE
createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo,
Optional<const AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainGrallocUsageOHOS( Format format, ImageUsageFlags imageUsage ) const;
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
@@ -10877,15 +10851,6 @@ namespace VULKAN_HPP_NAMESPACE
template <typename X, typename Y, typename... Z>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT;
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
typename ResultValueType<void>::type acquireOHOS( int32_t nativeFenceFd,
VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ),
VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const;
# endif /*VK_USE_PLATFORM_OHOS*/
protected:
Image( VULKAN_HPP_NAMESPACE::Device device,
VULKAN_HPP_NAMESPACE::Image image,
@@ -13023,15 +12988,6 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html
void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT;
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
VULKAN_HPP_NODISCARD typename ResultValueType<int32_t>::type
signalReleaseImageOHOS( ArrayProxy<const VULKAN_HPP_NAMESPACE::Semaphore> const & waitSemaphores, VULKAN_HPP_NAMESPACE::Image image ) const;
# endif /*VK_USE_PLATFORM_OHOS*/
private:
VULKAN_HPP_NAMESPACE::Queue m_queue = {};
detail::DeviceDispatcher const * m_dispatcher = nullptr;
@@ -27914,59 +27870,6 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
// wrapper function for command vkGetSwapchainGrallocUsageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainGrallocUsageOHOS.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint64_t>::type Device::getSwapchainGrallocUsageOHOS( Format format,
ImageUsageFlags imageUsage ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainGrallocUsageOHOS && "Function <vkGetSwapchainGrallocUsageOHOS> requires <VK_OHOS_native_buffer>" );
uint64_t grallocUsage;
Result result = static_cast<Result>( getDispatcher()->vkGetSwapchainGrallocUsageOHOS(
static_cast<VkDevice>( m_device ), static_cast<VkFormat>( format ), static_cast<VkImageUsageFlags>( imageUsage ), &grallocUsage ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSwapchainGrallocUsageOHOS" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( grallocUsage ) );
}
// wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html
VULKAN_HPP_INLINE typename ResultValueType<void>::type
Image::acquireOHOS( int32_t nativeFenceFd, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireImageOHOS && "Function <vkAcquireImageOHOS> requires <VK_OHOS_native_buffer>" );
Result result = static_cast<Result>( getDispatcher()->vkAcquireImageOHOS( static_cast<VkDevice>( m_device ),
static_cast<VkImage>( m_image ),
nativeFenceFd,
static_cast<VkSemaphore>( semaphore ),
static_cast<VkFence>( fence ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Image::acquireOHOS" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result );
}
// wrapper function for command vkQueueSignalReleaseImageOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSignalReleaseImageOHOS.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<int32_t>::type
Queue::signalReleaseImageOHOS( ArrayProxy<const VULKAN_HPP_NAMESPACE::Semaphore> const & waitSemaphores, VULKAN_HPP_NAMESPACE::Image image ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSignalReleaseImageOHOS && "Function <vkQueueSignalReleaseImageOHOS> requires <VK_OHOS_native_buffer>" );
int32_t nativeFenceFd;
Result result = static_cast<Result>( getDispatcher()->vkQueueSignalReleaseImageOHOS( static_cast<VkQueue>( m_queue ),
waitSemaphores.size(),
reinterpret_cast<const VkSemaphore *>( waitSemaphores.data() ),
static_cast<VkImage>( image ),
&nativeFenceFd ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::signalReleaseImageOHOS" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( nativeFenceFd ) );
}
# endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
// wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see
third_party/vulkan/vulkan_static_assertions.hpp
Vendored
+27 -22
View File
@@ -5213,6 +5213,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>::value,
"PhysicalDeviceCustomBorderColorFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_EXT_texture_compression_astc_3d ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT ) ==
sizeof( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT>::value,
"PhysicalDeviceTextureCompressionASTC3DFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_KHR_pipeline_library ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR ) == sizeof( VkPipelineLibraryCreateInfoKHR ),
@@ -9237,28 +9247,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
"SurfaceCreateInfoOHOS is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferOHOS ) == sizeof( VkNativeBufferOHOS ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>::value,
"NativeBufferOHOS is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS ) == sizeof( VkSwapchainImageCreateInfoOHOS ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>::value,
"SwapchainImageCreateInfoOHOS is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS ) == sizeof( VkPhysicalDevicePresentationPropertiesOHOS ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>::value,
"PhysicalDevicePresentationPropertiesOHOS is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ),
@@ -9589,6 +9577,23 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ResolveI
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>::value,
"ResolveImageModeInfoKHR is not nothrow_move_constructible!" );
//=== VK_EXT_shader_long_vector ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderLongVectorFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT>::value,
"PhysicalDeviceShaderLongVectorFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT ) ==
sizeof( VkPhysicalDeviceShaderLongVectorPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT>::value,
"PhysicalDeviceShaderLongVectorPropertiesEXT is not nothrow_move_constructible!" );
//=== VK_SEC_pipeline_cache_incremental_mode ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ) ==
third_party/vulkan/vulkan_structs.hpp
Vendored
+348 -344
View File
@@ -86823,127 +86823,6 @@ namespace VULKAN_HPP_NAMESPACE
};
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
// wrapper struct for struct VkNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferOHOS.html
struct NativeBufferOHOS
{
using NativeType = VkNativeBufferOHOS;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferOHOS;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR NativeBufferOHOS( struct OHBufferHandle * handle_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, handle{ handle_ }
{
}
VULKAN_HPP_CONSTEXPR NativeBufferOHOS( NativeBufferOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
NativeBufferOHOS( VkNativeBufferOHOS const & rhs ) VULKAN_HPP_NOEXCEPT : NativeBufferOHOS( *reinterpret_cast<NativeBufferOHOS const *>( &rhs ) ) {}
NativeBufferOHOS & operator=( NativeBufferOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
NativeBufferOHOS & operator=( VkNativeBufferOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<NativeBufferOHOS const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 NativeBufferOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 NativeBufferOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return std::move( *this );
}
VULKAN_HPP_CONSTEXPR_14 NativeBufferOHOS & setHandle( struct OHBufferHandle * handle_ ) & VULKAN_HPP_NOEXCEPT
{
handle = handle_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 NativeBufferOHOS && setHandle( struct OHBufferHandle * handle_ ) && VULKAN_HPP_NOEXCEPT
{
handle = handle_;
return std::move( *this );
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkNativeBufferOHOS const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkNativeBufferOHOS *>( this );
}
operator VkNativeBufferOHOS &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkNativeBufferOHOS *>( this );
}
operator VkNativeBufferOHOS const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkNativeBufferOHOS *>( this );
}
operator VkNativeBufferOHOS *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkNativeBufferOHOS *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, const void * const &, struct OHBufferHandle * const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, handle );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( NativeBufferOHOS const & ) const = default;
# else
bool operator==( NativeBufferOHOS 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 ) && ( handle == rhs.handle );
# endif
}
bool operator!=( NativeBufferOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
StructureType sType = StructureType::eNativeBufferOHOS;
const void * pNext = {};
struct OHBufferHandle * handle = {};
};
# if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkNativeBufferOHOS>
{
using Type = NativeBufferOHOS;
};
# endif
template <>
struct CppType<StructureType, StructureType::eNativeBufferOHOS>
{
using Type = NativeBufferOHOS;
};
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
// wrapper struct for struct VkNativeBufferPropertiesOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferPropertiesOHOS.html
struct NativeBufferPropertiesOHOS
@@ -124382,105 +124261,6 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDevicePresentWaitFeaturesKHR;
};
#if defined( VK_USE_PLATFORM_OHOS )
// wrapper struct for struct VkPhysicalDevicePresentationPropertiesOHOS, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentationPropertiesOHOS.html
struct PhysicalDevicePresentationPropertiesOHOS
{
using NativeType = VkPhysicalDevicePresentationPropertiesOHOS;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentationPropertiesOHOS;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDevicePresentationPropertiesOHOS( Bool32 sharedImage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, sharedImage{ sharedImage_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDevicePresentationPropertiesOHOS( PhysicalDevicePresentationPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDevicePresentationPropertiesOHOS( VkPhysicalDevicePresentationPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDevicePresentationPropertiesOHOS( *reinterpret_cast<PhysicalDevicePresentationPropertiesOHOS const *>( &rhs ) )
{
}
PhysicalDevicePresentationPropertiesOHOS & operator=( PhysicalDevicePresentationPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDevicePresentationPropertiesOHOS & operator=( VkPhysicalDevicePresentationPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDevicePresentationPropertiesOHOS const *>( &rhs );
return *this;
}
operator VkPhysicalDevicePresentationPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePresentationPropertiesOHOS *>( this );
}
operator VkPhysicalDevicePresentationPropertiesOHOS &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePresentationPropertiesOHOS *>( this );
}
operator VkPhysicalDevicePresentationPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDevicePresentationPropertiesOHOS *>( this );
}
operator VkPhysicalDevicePresentationPropertiesOHOS *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDevicePresentationPropertiesOHOS *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, sharedImage );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePresentationPropertiesOHOS const & ) const = default;
# else
bool operator==( PhysicalDevicePresentationPropertiesOHOS 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 ) && ( sharedImage == rhs.sharedImage );
# endif
}
bool operator!=( PhysicalDevicePresentationPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
StructureType sType = StructureType::ePhysicalDevicePresentationPropertiesOHOS;
void * pNext = {};
Bool32 sharedImage = {};
};
# if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDevicePresentationPropertiesOHOS>
{
using Type = PhysicalDevicePresentationPropertiesOHOS;
};
# endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDevicePresentationPropertiesOHOS>
{
using Type = PhysicalDevicePresentationPropertiesOHOS;
};
#endif /*VK_USE_PLATFORM_OHOS*/
// wrapper struct for struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html
struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
@@ -133549,6 +133329,226 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
};
// wrapper struct for struct VkPhysicalDeviceShaderLongVectorFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorFeaturesEXT.html
struct PhysicalDeviceShaderLongVectorFeaturesEXT
{
using NativeType = VkPhysicalDeviceShaderLongVectorFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( Bool32 longVector_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, longVector{ longVector_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderLongVectorFeaturesEXT( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderLongVectorFeaturesEXT( *reinterpret_cast<PhysicalDeviceShaderLongVectorFeaturesEXT const *>( &rhs ) )
{
}
PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceShaderLongVectorFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return std::move( *this );
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setLongVector( Bool32 longVector_ ) & VULKAN_HPP_NOEXCEPT
{
longVector = longVector_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setLongVector( Bool32 longVector_ ) && VULKAN_HPP_NOEXCEPT
{
longVector = longVector_;
return std::move( *this );
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderLongVectorFeaturesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorFeaturesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderLongVectorFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, longVector );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderLongVectorFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderLongVectorFeaturesEXT 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 ) && ( longVector == rhs.longVector );
# endif
}
bool operator!=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT;
void * pNext = {};
Bool32 longVector = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceShaderLongVectorFeaturesEXT>
{
using Type = PhysicalDeviceShaderLongVectorFeaturesEXT;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT>
{
using Type = PhysicalDeviceShaderLongVectorFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceShaderLongVectorPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorPropertiesEXT.html
struct PhysicalDeviceShaderLongVectorPropertiesEXT
{
using NativeType = VkPhysicalDeviceShaderLongVectorPropertiesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( uint32_t maxVectorComponents_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, maxVectorComponents{ maxVectorComponents_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderLongVectorPropertiesEXT( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderLongVectorPropertiesEXT( *reinterpret_cast<PhysicalDeviceShaderLongVectorPropertiesEXT const *>( &rhs ) )
{
}
PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceShaderLongVectorPropertiesEXT const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderLongVectorPropertiesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT *>( this );
}
operator VkPhysicalDeviceShaderLongVectorPropertiesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderLongVectorPropertiesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, maxVectorComponents );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderLongVectorPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderLongVectorPropertiesEXT 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 ) && ( maxVectorComponents == rhs.maxVectorComponents );
# endif
}
bool operator!=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT;
void * pNext = {};
uint32_t maxVectorComponents = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceShaderLongVectorPropertiesEXT>
{
using Type = PhysicalDeviceShaderLongVectorPropertiesEXT;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT>
{
using Type = PhysicalDeviceShaderLongVectorPropertiesEXT;
};
// wrapper struct for struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.html
struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR
@@ -137948,6 +137948,134 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
// wrapper struct for struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT.html
struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT
{
using NativeType = VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( Bool32 textureCompressionASTC_3D_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, textureCompressionASTC_3D{ textureCompressionASTC_3D_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( *reinterpret_cast<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *>( &rhs ) )
{
}
PhysicalDeviceTextureCompressionASTC3DFeaturesEXT &
operator=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & operator=( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return std::move( *this );
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) &
VULKAN_HPP_NOEXCEPT
{
textureCompressionASTC_3D = textureCompressionASTC_3D_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) &&
VULKAN_HPP_NOEXCEPT
{
textureCompressionASTC_3D = textureCompressionASTC_3D_;
return std::move( *this );
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>( this );
}
operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>( this );
}
operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>( this );
}
operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, textureCompressionASTC_3D );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT 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 ) && ( textureCompressionASTC_3D == rhs.textureCompressionASTC_3D );
# endif
}
bool operator!=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT;
void * pNext = {};
Bool32 textureCompressionASTC_3D = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT>
{
using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT>
{
using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html
struct PhysicalDeviceTextureCompressionASTCHDRFeatures
@@ -178291,130 +178419,6 @@ namespace VULKAN_HPP_NAMESPACE
using Type = SwapchainDisplayNativeHdrCreateInfoAMD;
};
#if defined( VK_USE_PLATFORM_OHOS )
// wrapper struct for struct VkSwapchainImageCreateInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainImageCreateInfoOHOS.html
struct SwapchainImageCreateInfoOHOS
{
using NativeType = VkSwapchainImageCreateInfoOHOS;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainImageCreateInfoOHOS;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR SwapchainImageCreateInfoOHOS( SwapchainImageUsageFlagsOHOS usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, usage{ usage_ }
{
}
VULKAN_HPP_CONSTEXPR SwapchainImageCreateInfoOHOS( SwapchainImageCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
SwapchainImageCreateInfoOHOS( VkSwapchainImageCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
: SwapchainImageCreateInfoOHOS( *reinterpret_cast<SwapchainImageCreateInfoOHOS const *>( &rhs ) )
{
}
SwapchainImageCreateInfoOHOS & operator=( SwapchainImageCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
SwapchainImageCreateInfoOHOS & operator=( VkSwapchainImageCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<SwapchainImageCreateInfoOHOS const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 SwapchainImageCreateInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SwapchainImageCreateInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return std::move( *this );
}
VULKAN_HPP_CONSTEXPR_14 SwapchainImageCreateInfoOHOS & setUsage( SwapchainImageUsageFlagsOHOS usage_ ) & VULKAN_HPP_NOEXCEPT
{
usage = usage_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SwapchainImageCreateInfoOHOS && setUsage( SwapchainImageUsageFlagsOHOS usage_ ) && VULKAN_HPP_NOEXCEPT
{
usage = usage_;
return std::move( *this );
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkSwapchainImageCreateInfoOHOS const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSwapchainImageCreateInfoOHOS *>( this );
}
operator VkSwapchainImageCreateInfoOHOS &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSwapchainImageCreateInfoOHOS *>( this );
}
operator VkSwapchainImageCreateInfoOHOS const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkSwapchainImageCreateInfoOHOS *>( this );
}
operator VkSwapchainImageCreateInfoOHOS *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkSwapchainImageCreateInfoOHOS *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, const void * const &, SwapchainImageUsageFlagsOHOS const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, usage );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SwapchainImageCreateInfoOHOS const & ) const = default;
# else
bool operator==( SwapchainImageCreateInfoOHOS 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 ) && ( usage == rhs.usage );
# endif
}
bool operator!=( SwapchainImageCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
StructureType sType = StructureType::eSwapchainImageCreateInfoOHOS;
const void * pNext = {};
SwapchainImageUsageFlagsOHOS usage = {};
};
# if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkSwapchainImageCreateInfoOHOS>
{
using Type = SwapchainImageCreateInfoOHOS;
};
# endif
template <>
struct CppType<StructureType, StructureType::eSwapchainImageCreateInfoOHOS>
{
using Type = SwapchainImageCreateInfoOHOS;
};
#endif /*VK_USE_PLATFORM_OHOS*/
// wrapper struct for struct VkSwapchainLatencyCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainLatencyCreateInfoNV.html
struct SwapchainLatencyCreateInfoNV
{
third_party/vulkan/vulkan_to_string.hpp
Vendored
+34 -34
View File
@@ -4302,23 +4302,6 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
VULKAN_HPP_INLINE std::string to_string( SwapchainImageUsageFlagsOHOS value )
{
std::string result = "{";
if ( value & SwapchainImageUsageFlagBitsOHOS::eShared )
result += " Shared |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_ARM_performance_counters_by_region ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagsARM )
@@ -5104,6 +5087,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eSamplerCustomBorderColorCreateInfoEXT : return "SamplerCustomBorderColorCreateInfoEXT";
case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT : return "PhysicalDeviceCustomBorderColorPropertiesEXT";
case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT : return "PhysicalDeviceCustomBorderColorFeaturesEXT";
case StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT : return "PhysicalDeviceTextureCompressionAstc3DFeaturesEXT";
case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR";
case StructureType::ePhysicalDevicePresentBarrierFeaturesNV : return "PhysicalDevicePresentBarrierFeaturesNV";
case StructureType::eSurfaceCapabilitiesPresentBarrierNV : return "SurfaceCapabilitiesPresentBarrierNV";
@@ -5597,10 +5581,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR : return "VideoDecodeH265InlineSessionParametersInfoKHR";
case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR : return "VideoDecodeAv1InlineSessionParametersInfoKHR";
#if defined( VK_USE_PLATFORM_OHOS )
case StructureType::eSurfaceCreateInfoOHOS : return "SurfaceCreateInfoOHOS";
case StructureType::eNativeBufferOHOS : return "NativeBufferOHOS";
case StructureType::eSwapchainImageCreateInfoOHOS : return "SwapchainImageCreateInfoOHOS";
case StructureType::ePhysicalDevicePresentationPropertiesOHOS: return "PhysicalDevicePresentationPropertiesOHOS";
case StructureType::eSurfaceCreateInfoOHOS: return "SurfaceCreateInfoOHOS";
#endif /*VK_USE_PLATFORM_OHOS*/
case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI : return "PhysicalDeviceHdrVividFeaturesHUAWEI";
case StructureType::eHdrVividDynamicMetadataHUAWEI : return "HdrVividDynamicMetadataHUAWEI";
@@ -5646,6 +5627,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR";
case StructureType::eRenderingEndInfoKHR : return "RenderingEndInfoKHR";
case StructureType::eResolveImageModeInfoKHR : return "ResolveImageModeInfoKHR";
case StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT : return "PhysicalDeviceShaderLongVectorFeaturesEXT";
case StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT : return "PhysicalDeviceShaderLongVectorPropertiesEXT";
case StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : return "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC";
case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT";
case StructureType::eComputeOccupancyPriorityParametersNV : return "ComputeOccupancyPriorityParametersNV";
@@ -5993,6 +5976,36 @@ namespace VULKAN_HPP_NAMESPACE
case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
case Format::eAstc3x3x3UnormBlockEXT : return "Astc3x3x3UnormBlockEXT";
case Format::eAstc3x3x3SrgbBlockEXT : return "Astc3x3x3SrgbBlockEXT";
case Format::eAstc3x3x3SfloatBlockEXT : return "Astc3x3x3SfloatBlockEXT";
case Format::eAstc4x3x3UnormBlockEXT : return "Astc4x3x3UnormBlockEXT";
case Format::eAstc4x3x3SrgbBlockEXT : return "Astc4x3x3SrgbBlockEXT";
case Format::eAstc4x3x3SfloatBlockEXT : return "Astc4x3x3SfloatBlockEXT";
case Format::eAstc4x4x3UnormBlockEXT : return "Astc4x4x3UnormBlockEXT";
case Format::eAstc4x4x3SrgbBlockEXT : return "Astc4x4x3SrgbBlockEXT";
case Format::eAstc4x4x3SfloatBlockEXT : return "Astc4x4x3SfloatBlockEXT";
case Format::eAstc4x4x4UnormBlockEXT : return "Astc4x4x4UnormBlockEXT";
case Format::eAstc4x4x4SrgbBlockEXT : return "Astc4x4x4SrgbBlockEXT";
case Format::eAstc4x4x4SfloatBlockEXT : return "Astc4x4x4SfloatBlockEXT";
case Format::eAstc5x4x4UnormBlockEXT : return "Astc5x4x4UnormBlockEXT";
case Format::eAstc5x4x4SrgbBlockEXT : return "Astc5x4x4SrgbBlockEXT";
case Format::eAstc5x4x4SfloatBlockEXT : return "Astc5x4x4SfloatBlockEXT";
case Format::eAstc5x5x4UnormBlockEXT : return "Astc5x5x4UnormBlockEXT";
case Format::eAstc5x5x4SrgbBlockEXT : return "Astc5x5x4SrgbBlockEXT";
case Format::eAstc5x5x4SfloatBlockEXT : return "Astc5x5x4SfloatBlockEXT";
case Format::eAstc5x5x5UnormBlockEXT : return "Astc5x5x5UnormBlockEXT";
case Format::eAstc5x5x5SrgbBlockEXT : return "Astc5x5x5SrgbBlockEXT";
case Format::eAstc5x5x5SfloatBlockEXT : return "Astc5x5x5SfloatBlockEXT";
case Format::eAstc6x5x5UnormBlockEXT : return "Astc6x5x5UnormBlockEXT";
case Format::eAstc6x5x5SrgbBlockEXT : return "Astc6x5x5SrgbBlockEXT";
case Format::eAstc6x5x5SfloatBlockEXT : return "Astc6x5x5SfloatBlockEXT";
case Format::eAstc6x6x5UnormBlockEXT : return "Astc6x6x5UnormBlockEXT";
case Format::eAstc6x6x5SrgbBlockEXT : return "Astc6x6x5SrgbBlockEXT";
case Format::eAstc6x6x5SfloatBlockEXT : return "Astc6x6x5SfloatBlockEXT";
case Format::eAstc6x6x6UnormBlockEXT : return "Astc6x6x6UnormBlockEXT";
case Format::eAstc6x6x6SrgbBlockEXT : return "Astc6x6x6SrgbBlockEXT";
case Format::eAstc6x6x6SfloatBlockEXT : return "Astc6x6x6SfloatBlockEXT";
case Format::eR8BoolARM : return "R8BoolARM";
case Format::eR16G16Sfixed5NV : return "R16G16Sfixed5NV";
case Format::eR10X6UintPack16ARM : return "R10X6UintPack16ARM";
@@ -10906,19 +10919,6 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /*VK_USE_PLATFORM_OHOS*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_native_buffer ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SwapchainImageUsageFlagBitsOHOS value )
{
switch ( value )
{
case SwapchainImageUsageFlagBitsOHOS::eShared: return "Shared";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_ARM_performance_counters_by_region ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsARM )