diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index 0f5384a..ca1c892 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -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; + //=== VK_EXT_texture_compression_astc_3d === + template <> + struct hash; + //=== VK_KHR_pipeline_library === template <> struct hash; @@ -9331,16 +9331,6 @@ export namespace std struct hash; #endif /*VK_USE_PLATFORM_OHOS*/ -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_native_buffer === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_OHOS*/ - //=== VK_HUAWEI_hdr_vivid === template <> struct hash; @@ -9463,6 +9453,12 @@ export namespace std template <> struct hash; + //=== VK_EXT_shader_long_vector === + template <> + struct hash; + template <> + struct hash; + //=== VK_SEC_pipeline_cache_incremental_mode === template <> struct hash; @@ -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; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 57b5b0a..c05ead1 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -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!" ); // includes 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 @@ -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 + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_pipeline_library === template <> struct StructExtends @@ -19492,45 +19493,6 @@ namespace VULKAN_HPP_NAMESPACE }; }; -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_native_buffer === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - //=== VK_HUAWEI_hdr_vivid === template <> struct StructExtends @@ -20039,6 +20001,34 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_shader_long_vector === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_SEC_pipeline_cache_incremental_mode === template <> struct StructExtends @@ -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" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 922db39..d176035 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 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 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index a68680e..71fb615 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -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; - - template <> - struct FlagTraits - { - 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 diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 33acb60..c130781 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -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 ) diff --git a/third_party/vulkan/vulkan_format_traits.hpp b/third_party/vulkan/vulkan_format_traits.hpp index 5e57417..462f950 100644 --- a/third_party/vulkan/vulkan_format_traits.hpp +++ b/third_party/vulkan/vulkan_format_traits.hpp @@ -197,6 +197,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return { { 4, 4, 1 } }; case Format::ePvrtc22BppSrgbBlockIMG : return { { 8, 4, 1 } }; case Format::ePvrtc24BppSrgbBlockIMG : return { { 4, 4, 1 } }; + case Format::eAstc3x3x3UnormBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc3x3x3SrgbBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc3x3x3SfloatBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc4x3x3UnormBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x3x3SrgbBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x3x3SfloatBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x4x3UnormBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x3SrgbBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x3SfloatBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x4UnormBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc4x4x4SrgbBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc4x4x4SfloatBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc5x4x4UnormBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x4x4SrgbBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x4x4SfloatBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x5x4UnormBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x4SrgbBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x4SfloatBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x5UnormBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc5x5x5SrgbBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc5x5x5SfloatBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc6x5x5UnormBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x5x5SrgbBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x5x5SfloatBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x6x5UnormBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x5SrgbBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x5SfloatBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x6UnormBlockEXT : return { { 6, 6, 6 } }; + case Format::eAstc6x6x6SrgbBlockEXT : return { { 6, 6, 6 } }; + case Format::eAstc6x6x6SfloatBlockEXT : return { { 6, 6, 6 } }; default: return { { 1, 1, 1 } }; } @@ -455,6 +485,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return 8; case Format::ePvrtc22BppSrgbBlockIMG : return 8; case Format::ePvrtc24BppSrgbBlockIMG : return 8; + case Format::eAstc3x3x3UnormBlockEXT : return 16; + case Format::eAstc3x3x3SrgbBlockEXT : return 16; + case Format::eAstc3x3x3SfloatBlockEXT : return 16; + case Format::eAstc4x3x3UnormBlockEXT : return 16; + case Format::eAstc4x3x3SrgbBlockEXT : return 16; + case Format::eAstc4x3x3SfloatBlockEXT : return 16; + case Format::eAstc4x4x3UnormBlockEXT : return 16; + case Format::eAstc4x4x3SrgbBlockEXT : return 16; + case Format::eAstc4x4x3SfloatBlockEXT : return 16; + case Format::eAstc4x4x4UnormBlockEXT : return 16; + case Format::eAstc4x4x4SrgbBlockEXT : return 16; + case Format::eAstc4x4x4SfloatBlockEXT : return 16; + case Format::eAstc5x4x4UnormBlockEXT : return 16; + case Format::eAstc5x4x4SrgbBlockEXT : return 16; + case Format::eAstc5x4x4SfloatBlockEXT : return 16; + case Format::eAstc5x5x4UnormBlockEXT : return 16; + case Format::eAstc5x5x4SrgbBlockEXT : return 16; + case Format::eAstc5x5x4SfloatBlockEXT : return 16; + case Format::eAstc5x5x5UnormBlockEXT : return 16; + case Format::eAstc5x5x5SrgbBlockEXT : return 16; + case Format::eAstc5x5x5SfloatBlockEXT : return 16; + case Format::eAstc6x5x5UnormBlockEXT : return 16; + case Format::eAstc6x5x5SrgbBlockEXT : return 16; + case Format::eAstc6x5x5SfloatBlockEXT : return 16; + case Format::eAstc6x6x5UnormBlockEXT : return 16; + case Format::eAstc6x6x5SrgbBlockEXT : return 16; + case Format::eAstc6x6x5SfloatBlockEXT : return 16; + case Format::eAstc6x6x6UnormBlockEXT : return 16; + case Format::eAstc6x6x6SrgbBlockEXT : return 16; + case Format::eAstc6x6x6SfloatBlockEXT : return 16; case Format::eR8BoolARM : return 1; case Format::eR16G16Sfixed5NV : return 4; case Format::eR10X6UintPack16ARM : return 2; @@ -729,6 +789,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC1_4BPP"; case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC2_2BPP"; case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC2_4BPP"; + case Format::eAstc3x3x3UnormBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc3x3x3SfloatBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc4x3x3UnormBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x3x3SfloatBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x4x3UnormBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x3SfloatBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x4UnormBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc4x4x4SfloatBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc5x4x4UnormBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x4x4SfloatBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x5x4UnormBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x4SfloatBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x5UnormBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc5x5x5SfloatBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc6x5x5UnormBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x5x5SfloatBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x6x5UnormBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x5SfloatBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x6UnormBlockEXT : return "ASTC_6x6x6"; + case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC_6x6x6"; + case Format::eAstc6x6x6SfloatBlockEXT : return "ASTC_6x6x6"; case Format::eR8BoolARM : return "8-bit"; case Format::eR16G16Sfixed5NV : return "32-bit"; case Format::eR10X6UintPack16ARM : return "16-bit"; @@ -2516,6 +2606,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return 4; case Format::ePvrtc22BppSrgbBlockIMG : return 4; case Format::ePvrtc24BppSrgbBlockIMG : return 4; + case Format::eAstc3x3x3UnormBlockEXT : return 4; + case Format::eAstc3x3x3SrgbBlockEXT : return 4; + case Format::eAstc3x3x3SfloatBlockEXT : return 4; + case Format::eAstc4x3x3UnormBlockEXT : return 4; + case Format::eAstc4x3x3SrgbBlockEXT : return 4; + case Format::eAstc4x3x3SfloatBlockEXT : return 4; + case Format::eAstc4x4x3UnormBlockEXT : return 4; + case Format::eAstc4x4x3SrgbBlockEXT : return 4; + case Format::eAstc4x4x3SfloatBlockEXT : return 4; + case Format::eAstc4x4x4UnormBlockEXT : return 4; + case Format::eAstc4x4x4SrgbBlockEXT : return 4; + case Format::eAstc4x4x4SfloatBlockEXT : return 4; + case Format::eAstc5x4x4UnormBlockEXT : return 4; + case Format::eAstc5x4x4SrgbBlockEXT : return 4; + case Format::eAstc5x4x4SfloatBlockEXT : return 4; + case Format::eAstc5x5x4UnormBlockEXT : return 4; + case Format::eAstc5x5x4SrgbBlockEXT : return 4; + case Format::eAstc5x5x4SfloatBlockEXT : return 4; + case Format::eAstc5x5x5UnormBlockEXT : return 4; + case Format::eAstc5x5x5SrgbBlockEXT : return 4; + case Format::eAstc5x5x5SfloatBlockEXT : return 4; + case Format::eAstc6x5x5UnormBlockEXT : return 4; + case Format::eAstc6x5x5SrgbBlockEXT : return 4; + case Format::eAstc6x5x5SfloatBlockEXT : return 4; + case Format::eAstc6x6x5UnormBlockEXT : return 4; + case Format::eAstc6x6x5SrgbBlockEXT : return 4; + case Format::eAstc6x6x5SfloatBlockEXT : return 4; + case Format::eAstc6x6x6UnormBlockEXT : return 4; + case Format::eAstc6x6x6SrgbBlockEXT : return 4; + case Format::eAstc6x6x6SfloatBlockEXT : return 4; case Format::eR8BoolARM : return 1; case Format::eR16G16Sfixed5NV : return 2; case Format::eR10X6UintPack16ARM : return 1; @@ -4560,6 +4680,276 @@ namespace VULKAN_HPP_NAMESPACE case 3 : return "A"; default: VULKAN_HPP_ASSERT( false ); return ""; } + case Format::eAstc3x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } case Format::eR8BoolARM: switch ( component ) { @@ -6705,6 +7095,276 @@ namespace VULKAN_HPP_NAMESPACE case 3 : return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } + case Format::eAstc3x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } case Format::eR8BoolARM: switch ( component ) { @@ -7121,7 +7781,37 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc12BppSrgbBlockIMG: case Format::ePvrtc14BppSrgbBlockIMG: case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG : return true; + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: return true; default : return false; } } @@ -7207,6 +7897,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC"; case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC"; case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC"; + case Format::eAstc3x3x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc3x3x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x3x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x3x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x4x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x4x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x4x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x4x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x5x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x5x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x5x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x5x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x6x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x6x6UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x6SfloatBlockEXT: return "ASTC HDR"; default: return ""; } @@ -7463,6 +8183,36 @@ namespace VULKAN_HPP_NAMESPACE Format::ePvrtc14BppSrgbBlockIMG, Format::ePvrtc22BppSrgbBlockIMG, Format::ePvrtc24BppSrgbBlockIMG, + Format::eAstc3x3x3UnormBlockEXT, + Format::eAstc3x3x3SrgbBlockEXT, + Format::eAstc3x3x3SfloatBlockEXT, + Format::eAstc4x3x3UnormBlockEXT, + Format::eAstc4x3x3SrgbBlockEXT, + Format::eAstc4x3x3SfloatBlockEXT, + Format::eAstc4x4x3UnormBlockEXT, + Format::eAstc4x4x3SrgbBlockEXT, + Format::eAstc4x4x3SfloatBlockEXT, + Format::eAstc4x4x4UnormBlockEXT, + Format::eAstc4x4x4SrgbBlockEXT, + Format::eAstc4x4x4SfloatBlockEXT, + Format::eAstc5x4x4UnormBlockEXT, + Format::eAstc5x4x4SrgbBlockEXT, + Format::eAstc5x4x4SfloatBlockEXT, + Format::eAstc5x5x4UnormBlockEXT, + Format::eAstc5x5x4SrgbBlockEXT, + Format::eAstc5x5x4SfloatBlockEXT, + Format::eAstc5x5x5UnormBlockEXT, + Format::eAstc5x5x5SrgbBlockEXT, + Format::eAstc5x5x5SfloatBlockEXT, + Format::eAstc6x5x5UnormBlockEXT, + Format::eAstc6x5x5SrgbBlockEXT, + Format::eAstc6x5x5SfloatBlockEXT, + Format::eAstc6x6x5UnormBlockEXT, + Format::eAstc6x6x5SrgbBlockEXT, + Format::eAstc6x6x5SfloatBlockEXT, + Format::eAstc6x6x6UnormBlockEXT, + Format::eAstc6x6x6SrgbBlockEXT, + Format::eAstc6x6x6SfloatBlockEXT, Format::eR8BoolARM, Format::eR16G16Sfixed5NV, Format::eR10X6UintPack16ARM, @@ -7726,6 +8476,36 @@ namespace VULKAN_HPP_NAMESPACE Format::ePvrtc14BppSrgbBlockIMG, Format::ePvrtc22BppSrgbBlockIMG, Format::ePvrtc24BppSrgbBlockIMG, + Format::eAstc3x3x3UnormBlockEXT, + Format::eAstc3x3x3SrgbBlockEXT, + Format::eAstc3x3x3SfloatBlockEXT, + Format::eAstc4x3x3UnormBlockEXT, + Format::eAstc4x3x3SrgbBlockEXT, + Format::eAstc4x3x3SfloatBlockEXT, + Format::eAstc4x4x3UnormBlockEXT, + Format::eAstc4x4x3SrgbBlockEXT, + Format::eAstc4x4x3SfloatBlockEXT, + Format::eAstc4x4x4UnormBlockEXT, + Format::eAstc4x4x4SrgbBlockEXT, + Format::eAstc4x4x4SfloatBlockEXT, + Format::eAstc5x4x4UnormBlockEXT, + Format::eAstc5x4x4SrgbBlockEXT, + Format::eAstc5x4x4SfloatBlockEXT, + Format::eAstc5x5x4UnormBlockEXT, + Format::eAstc5x5x4SrgbBlockEXT, + Format::eAstc5x5x4SfloatBlockEXT, + Format::eAstc5x5x5UnormBlockEXT, + Format::eAstc5x5x5SrgbBlockEXT, + Format::eAstc5x5x5SfloatBlockEXT, + Format::eAstc6x5x5UnormBlockEXT, + Format::eAstc6x5x5SrgbBlockEXT, + Format::eAstc6x5x5SfloatBlockEXT, + Format::eAstc6x6x5UnormBlockEXT, + Format::eAstc6x6x5SrgbBlockEXT, + Format::eAstc6x6x5SfloatBlockEXT, + Format::eAstc6x6x6UnormBlockEXT, + Format::eAstc6x6x6SrgbBlockEXT, + Format::eAstc6x6x6SfloatBlockEXT, Format::eR8BoolARM, Format::eR16G16Sfixed5NV, Format::eR10X6UintPack16ARM, @@ -7891,6 +8671,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG: case Format::ePvrtc22BppSrgbBlockIMG: case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: @@ -8091,6 +8901,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG: case Format::ePvrtc22BppSrgbBlockIMG: case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: @@ -8335,6 +9175,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG: case Format::ePvrtc22BppSrgbBlockIMG: case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: case Format::eR16G16Sfixed5NV: case Format::eR10X6G10X6Uint2Pack16ARM: case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: @@ -8595,6 +9465,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG: case Format::ePvrtc22BppSrgbBlockIMG: case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: case Format::eR8BoolARM: case Format::eR16G16Sfixed5NV: case Format::eR10X6UintPack16ARM: @@ -9621,6 +10521,36 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return 1; case Format::ePvrtc22BppSrgbBlockIMG : return 1; case Format::ePvrtc24BppSrgbBlockIMG : return 1; + case Format::eAstc3x3x3UnormBlockEXT : return 27; + case Format::eAstc3x3x3SrgbBlockEXT : return 27; + case Format::eAstc3x3x3SfloatBlockEXT : return 27; + case Format::eAstc4x3x3UnormBlockEXT : return 36; + case Format::eAstc4x3x3SrgbBlockEXT : return 36; + case Format::eAstc4x3x3SfloatBlockEXT : return 36; + case Format::eAstc4x4x3UnormBlockEXT : return 48; + case Format::eAstc4x4x3SrgbBlockEXT : return 48; + case Format::eAstc4x4x3SfloatBlockEXT : return 48; + case Format::eAstc4x4x4UnormBlockEXT : return 64; + case Format::eAstc4x4x4SrgbBlockEXT : return 64; + case Format::eAstc4x4x4SfloatBlockEXT : return 64; + case Format::eAstc5x4x4UnormBlockEXT : return 80; + case Format::eAstc5x4x4SrgbBlockEXT : return 80; + case Format::eAstc5x4x4SfloatBlockEXT : return 80; + case Format::eAstc5x5x4UnormBlockEXT : return 100; + case Format::eAstc5x5x4SrgbBlockEXT : return 100; + case Format::eAstc5x5x4SfloatBlockEXT : return 100; + case Format::eAstc5x5x5UnormBlockEXT : return 125; + case Format::eAstc5x5x5SrgbBlockEXT : return 125; + case Format::eAstc5x5x5SfloatBlockEXT : return 125; + case Format::eAstc6x5x5UnormBlockEXT : return 150; + case Format::eAstc6x5x5SrgbBlockEXT : return 150; + case Format::eAstc6x5x5SfloatBlockEXT : return 150; + case Format::eAstc6x6x5UnormBlockEXT : return 180; + case Format::eAstc6x6x5SrgbBlockEXT : return 180; + case Format::eAstc6x6x5SfloatBlockEXT : return 180; + case Format::eAstc6x6x6UnormBlockEXT : return 216; + case Format::eAstc6x6x6SrgbBlockEXT : return 216; + case Format::eAstc6x6x6SfloatBlockEXT : return 216; case Format::eR8BoolARM : return 1; case Format::eR16G16Sfixed5NV : return 1; case Format::eR10X6UintPack16ARM : return 1; diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index c0d6eaf..ea090c0 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -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 ::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( d.vkGetSwapchainGrallocUsageOHOS( - static_cast( m_device ), static_cast( format ), static_cast( 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 ::value, bool>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::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 requires " ); -# endif - - uint64_t grallocUsage; - Result result = static_cast( - d.vkGetSwapchainGrallocUsageOHOS( m_device, static_cast( format ), static_cast( 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 ::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( d.vkAcquireImageOHOS( - static_cast( m_device ), static_cast( image ), nativeFenceFd, static_cast( semaphore ), static_cast( fence ) ) ); - } -# else - // wrapper function for command vkAcquireImageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireImageOHOS.html - template ::value, bool>::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::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 requires " ); -# endif - - Result result = static_cast( - d.vkAcquireImageOHOS( m_device, static_cast( image ), nativeFenceFd, static_cast( semaphore ), static_cast( 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 ::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( d.vkQueueSignalReleaseImageOHOS( static_cast( m_queue ), - waitSemaphoreCount, - reinterpret_cast( pWaitSemaphores ), - static_cast( 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 ::value, bool>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Queue::signalReleaseImageOHOS( ArrayProxy 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 requires " ); -# endif - - int32_t nativeFenceFd; - Result result = static_cast( d.vkQueueSignalReleaseImageOHOS( - m_queue, waitSemaphores.size(), reinterpret_cast( waitSemaphores.data() ), static_cast( 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 diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index af5d42b..81b6aa1 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -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 - { - using Type = Image; - }; - - template <> - struct CppType - { - using Type = Image; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Image; - }; -#endif - - template <> - struct isVulkanHandleType - { - 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 + { + using Type = Image; + }; + + template <> + struct CppType + { + using Type = Image; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Image; + }; +#endif + + template <> + struct isVulkanHandleType + { + 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 ::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 ::value, bool>::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type signalReleaseImageOHOS( ArrayProxy 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 ::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 ::value, bool>::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::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 ::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 ::value, bool>::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::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 === diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 84d9c15..e8312c6 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -8598,21 +8598,6 @@ namespace std }; # endif /*VK_USE_PLATFORM_OHOS*/ -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - 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 @@ -13017,22 +13002,6 @@ namespace std } }; -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - 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 { @@ -14075,6 +14044,34 @@ namespace std } }; + template <> + struct hash + { + 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 + { + 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 { @@ -14595,6 +14592,20 @@ namespace std } }; + template <> + struct hash + { + 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 { @@ -18599,21 +18610,6 @@ namespace std } }; -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - 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 { diff --git a/third_party/vulkan/vulkan_ohos.h b/third_party/vulkan/vulkan_ohos.h index 0731e55..9c41b1d 100644 --- a/third_party/vulkan/vulkan_ohos.h +++ b/third_party/vulkan/vulkan_ohos.h @@ -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 diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 6d9a41f..b821b63 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -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 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::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 VULKAN_HPP_NODISCARD StructureChain 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::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::type - signalReleaseImageOHOS( ArrayProxy 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::type Device::getSwapchainGrallocUsageOHOS( Format format, - ImageUsageFlags imageUsage ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainGrallocUsageOHOS && "Function requires " ); - - uint64_t grallocUsage; - Result result = static_cast( getDispatcher()->vkGetSwapchainGrallocUsageOHOS( - static_cast( m_device ), static_cast( format ), static_cast( 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::type - Image::acquireOHOS( int32_t nativeFenceFd, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireImageOHOS && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkAcquireImageOHOS( static_cast( m_device ), - static_cast( m_image ), - nativeFenceFd, - static_cast( semaphore ), - static_cast( 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::type - Queue::signalReleaseImageOHOS( ArrayProxy const & waitSemaphores, VULKAN_HPP_NAMESPACE::Image image ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSignalReleaseImageOHOS && "Function requires " ); - - int32_t nativeFenceFd; - Result result = static_cast( getDispatcher()->vkQueueSignalReleaseImageOHOS( static_cast( m_queue ), - waitSemaphores.size(), - reinterpret_cast( waitSemaphores.data() ), - static_cast( 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 diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index f51aa8d..75a7853 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -5213,6 +5213,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::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::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::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::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderLongVectorPropertiesEXT is not nothrow_move_constructible!" ); + //=== VK_SEC_pipeline_cache_incremental_mode === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ) == diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index de16609..1a7d5b2 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -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( &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( &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( this ); - } - - operator VkNativeBufferOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkNativeBufferOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, 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 - { - using Type = NativeBufferOHOS; - }; -# endif - - template <> - struct CppType - { - 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( &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( &rhs ); - return *this; - } - - operator VkPhysicalDevicePresentationPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentationPropertiesOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentationPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentationPropertiesOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, 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 - { - using Type = PhysicalDevicePresentationPropertiesOHOS; - }; -# endif - - template <> - struct CppType - { - 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( &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( &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( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, 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 + { + using Type = PhysicalDeviceShaderLongVectorFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + 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( &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( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, 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 + { + using Type = PhysicalDeviceShaderLongVectorPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + 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( &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( &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( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, 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 + { + using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + 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( &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( &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( this ); - } - - operator VkSwapchainImageCreateInfoOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainImageCreateInfoOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainImageCreateInfoOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, 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 - { - using Type = SwapchainImageCreateInfoOHOS; - }; -# endif - - template <> - struct CppType - { - 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 { diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index b57dcb2..66714b1 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -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( value ) ) + " )"; - } - } -#endif /*VK_USE_PLATFORM_OHOS*/ - //=== VK_ARM_performance_counters_by_region === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsARM )