From fad90eadf6bb26729dc74d2080d36f706d9d5288 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 8 Dec 2020 10:28:51 +0100 Subject: [PATCH] Update to VK_HEADER_VERSION 164. --- Vulkan-Headers | 2 +- VulkanHppGenerator.cpp | 67 +++--- vulkan/vulkan.hpp | 527 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 534 insertions(+), 62 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index 6a163aa..fe98507 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 6a163aa97f8a3d1c186138bedbfb76ce117be8d1 +Subproject commit fe9850767d00e46b230da6cfbc15eb86636017bd diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 087b9fa..cc72544 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -2804,22 +2804,14 @@ ${CppTypeFromDebugReportObjectTypeEXT} std::string enter, leave; std::tie( enter, leave ) = generateProtection( handleData.first, !handleData.second.alias.empty() ); - std::string objTypeEnum; - if ( handleData.second.objTypeEnum.empty() ) - { - objTypeEnum = "e" + stripPrefix( handleData.first, "Vk" ); - } - else - { - enumIt = m_enums.find( "VkObjectType" ); - assert( enumIt != m_enums.end() ); - valueIt = std::find_if( - enumIt->second.values.begin(), enumIt->second.values.end(), [&handleData]( EnumValueData const & evd ) { - return evd.vulkanValue == handleData.second.objTypeEnum; - } ); - assert( valueIt != enumIt->second.values.end() ); - objTypeEnum = valueIt->vkValue; - } + assert( !handleData.second.objTypeEnum.empty() ); + enumIt = m_enums.find( "VkObjectType" ); + assert( enumIt != m_enums.end() ); + valueIt = std::find_if( + enumIt->second.values.begin(), enumIt->second.values.end(), [&handleData]( EnumValueData const & evd ) { + return evd.vulkanValue == handleData.second.objTypeEnum; + } ); + assert( valueIt != enumIt->second.values.end() ); str += replaceWithMap( templateString, { { "className", className }, @@ -2828,7 +2820,7 @@ ${CppTypeFromDebugReportObjectTypeEXT} { "debugReportObjectType", debugReportObjectType }, { "enter", enter }, { "memberName", startLowerCase( stripPrefix( handleData.first, "Vk" ) ) }, - { "objTypeEnum", objTypeEnum } } ); + { "objTypeEnum", valueIt->vkValue } } ); if ( !handleData.second.alias.empty() ) { @@ -6598,33 +6590,21 @@ void VulkanHppGenerator::checkCorrectness() if ( !handle.first.empty() ) { - if ( handle.second.objTypeEnum.empty() ) - { - std::string objectType = "e" + stripPrefix( handle.first, "Vk" ); - auto valueIt = std::find_if( objectTypeIt->second.values.begin(), - objectTypeIt->second.values.end(), - [&objectType]( EnumValueData const & evd ) { return evd.vkValue == objectType; } ); - check( valueIt != objectTypeIt->second.values.end(), - handle.second.xmlLine, - "handle <" + handle.first + "> specified without corresponding VkObjectType enum value" ); - } - else - { - check( std::find_if( objectTypeIt->second.values.begin(), - objectTypeIt->second.values.end(), - [&handle]( EnumValueData const & evd ) { - return evd.vulkanValue == handle.second.objTypeEnum; - } ) != objectTypeIt->second.values.end(), - handle.second.xmlLine, - "handle <" + handle.first + "> specifies unknown \"objtypeenum\" <" + handle.second.objTypeEnum + ">" ); - } + assert( !handle.second.objTypeEnum.empty() ); + check( std::find_if( objectTypeIt->second.values.begin(), + objectTypeIt->second.values.end(), + [&handle]( EnumValueData const & evd ) { + return evd.vulkanValue == handle.second.objTypeEnum; + } ) != objectTypeIt->second.values.end(), + handle.second.xmlLine, + "handle <" + handle.first + "> specifies unknown \"objtypeenum\" <" + handle.second.objTypeEnum + ">" ); } } for ( auto const & objectTypeValue : objectTypeIt->second.values ) { if ( objectTypeValue.vkValue != "eUnknown" ) { - warn( std::find_if( m_handles.begin(), + check( std::find_if( m_handles.begin(), m_handles.end(), [&objectTypeValue]( std::pair const & hd ) { return hd.second.objTypeEnum == objectTypeValue.vulkanValue; @@ -8533,7 +8513,7 @@ void VulkanHppGenerator::readHandle( tinyxml2::XMLElement const * "handle with invalid type <" + typeInfo.type + ">" ); check( typeInfo.prefix.empty(), line, "unexpected type prefix <" + typeInfo.prefix + ">" ); check( typeInfo.postfix == "(", line, "unexpected type postfix <" + typeInfo.postfix + ">" ); - warn( !objTypeEnum.empty(), line, "handle <" + nameData.name + "> does not specify attribute \"objtypeenum\"" ); + check( !objTypeEnum.empty(), line, "handle <" + nameData.name + "> does not specify attribute \"objtypeenum\"" ); check( m_handles.insert( std::make_pair( nameData.name, HandleData( tokenize( parent, "," ), objTypeEnum, line ) ) ) .second, @@ -9182,6 +9162,15 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const * readStructMember( child, it->second.members, isUnion ); } } + if ( name == "VkDescriptorSetAllocateInfo" ) + { + // some very very very special handling for this struct: the "len" attribute for pSetLayouts has gone! + assert( ( it->second.members.size() == 5 ) && ( it->second.members[3].name == "descriptorSetCount" ) && ( it->second.members[4].name == "pSetLayouts" )); + warn( !it->second.members[4].len.empty(), + line, + "Missing attribute \"len\" for member in structure " ); + it->second.members[4].len = { it->second.members[3].name }; + } it->second.subStruct = determineSubStruct( *it ); m_extendedStructs.insert( structExtends.begin(), structExtends.end() ); diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index bb90dea..54d4e25 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 163, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 164, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -1276,6 +1276,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkAcquireProfilingLockKHR( device, pInfo ); } +# ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireWinrtDisplayNV( physicalDevice, display ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + # ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, @@ -4472,6 +4479,15 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData ); } +# ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT { @@ -6204,6 +6220,7 @@ namespace VULKAN_HPP_NAMESPACE { eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE, eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT }; @@ -6213,6 +6230,7 @@ namespace VULKAN_HPP_NAMESPACE { case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet"; case DescriptorPoolCreateFlagBits::eUpdateAfterBind: return "UpdateAfterBind"; + case DescriptorPoolCreateFlagBits::eHostOnlyVALVE: return "HostOnlyVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6221,6 +6239,7 @@ namespace VULKAN_HPP_NAMESPACE { eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + eHostOnlyPoolVALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT }; @@ -6230,6 +6249,7 @@ namespace VULKAN_HPP_NAMESPACE { case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool: return "UpdateAfterBindPool"; case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR"; + case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE: return "HostOnlyPoolVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6249,7 +6269,8 @@ namespace VULKAN_HPP_NAMESPACE eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, - eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV + eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, + eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE }; VULKAN_HPP_INLINE std::string to_string( DescriptorType value ) @@ -6270,6 +6291,7 @@ namespace VULKAN_HPP_NAMESPACE case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT"; case DescriptorType::eAccelerationStructureKHR: return "AccelerationStructureKHR"; case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV"; + case DescriptorType::eMutableVALVE: return "MutableVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -10076,20 +10098,23 @@ namespace VULKAN_HPP_NAMESPACE eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT, - eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, - eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, - eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, - eAttachmentReferenceStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR, - eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, - eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, - eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, - eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, - eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, - eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, - eBufferDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, - eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, - eBufferOpaqueCaptureAddressCreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, - eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, + ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, + eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, + eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, + eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, + eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, + eAttachmentReferenceStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR, + eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, + eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, + eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, + eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, + eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, + eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, + eBufferDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + eBufferOpaqueCaptureAddressCreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, + eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR, @@ -10804,6 +10829,9 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eImageResolve2KHR: return "ImageResolve2KHR"; case StructureType::ePhysicalDevice4444FormatsFeaturesEXT: return "PhysicalDevice4444FormatsFeaturesEXT"; case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT"; + case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE: + return "PhysicalDeviceMutableDescriptorTypeFeaturesVALVE"; + case StructureType::eMutableDescriptorTypeCreateInfoVALVE: return "MutableDescriptorTypeCreateInfoVALVE"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -11105,7 +11133,8 @@ namespace VULKAN_HPP_NAMESPACE eVSI = VK_VENDOR_ID_VSI, eKazan = VK_VENDOR_ID_KAZAN, eCodeplay = VK_VENDOR_ID_CODEPLAY, - eMESA = VK_VENDOR_ID_MESA + eMESA = VK_VENDOR_ID_MESA, + ePocl = VK_VENDOR_ID_POCL }; VULKAN_HPP_INLINE std::string to_string( VendorId value ) @@ -11117,6 +11146,7 @@ namespace VULKAN_HPP_NAMESPACE case VendorId::eKazan: return "Kazan"; case VendorId::eCodeplay: return "Codeplay"; case VendorId::eMESA: return "MESA"; + case VendorId::ePocl: return "Pocl"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -12379,7 +12409,8 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags { allFlags = VkFlags( DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) | - VkFlags( DescriptorPoolCreateFlagBits::eUpdateAfterBind ) + VkFlags( DescriptorPoolCreateFlagBits::eUpdateAfterBind ) | + VkFlags( DescriptorPoolCreateFlagBits::eHostOnlyVALVE ) }; }; @@ -12417,6 +12448,8 @@ namespace VULKAN_HPP_NAMESPACE result += "FreeDescriptorSet | "; if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) result += "UpdateAfterBind | "; + if ( value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE ) + result += "HostOnlyVALVE | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -12444,7 +12477,8 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags { allFlags = VkFlags( DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) | - VkFlags( DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) + VkFlags( DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) | + VkFlags( DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE ) }; }; @@ -12482,6 +12516,8 @@ namespace VULKAN_HPP_NAMESPACE result += "UpdateAfterBindPool | "; if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) result += "PushDescriptorKHR | "; + if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE ) + result += "HostOnlyPoolVALVE | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -55771,8 +55807,8 @@ namespace VULKAN_HPP_NAMESPACE # else template VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -60733,6 +60769,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif +#ifdef VK_USE_PLATFORM_WIN32_KHR +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD Result + acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# else + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT template VULKAN_HPP_NODISCARD Result @@ -61932,6 +61982,26 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_NODISCARD Result + getWinrtDisplayNV( uint32_t deviceRelativeId, + VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType>::type + getWinrtDisplayNVUnique( uint32_t deviceRelativeId, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, @@ -68288,6 +68358,224 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ + struct MutableDescriptorTypeListVALVE + { +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE( + uint32_t descriptorTypeCount_ = {}, + const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes_ = {} ) VULKAN_HPP_NOEXCEPT + : descriptorTypeCount( descriptorTypeCount_ ) + , pDescriptorTypes( pDescriptorTypes_ ) + {} + + VULKAN_HPP_CONSTEXPR + MutableDescriptorTypeListVALVE( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeListVALVE( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeListVALVE( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + descriptorTypes_ ) + : descriptorTypeCount( static_cast( descriptorTypes_.size() ) ) + , pDescriptorTypes( descriptorTypes_.data() ) + {} +# endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + MutableDescriptorTypeListVALVE & operator=( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( MutableDescriptorTypeListVALVE ) ); + return *this; + } + + MutableDescriptorTypeListVALVE & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = descriptorTypeCount_; + return *this; + } + + MutableDescriptorTypeListVALVE & + setPDescriptorTypes( const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + pDescriptorTypes = pDescriptorTypes_; + return *this; + } + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeListVALVE & setDescriptorTypes( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + descriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = static_cast( descriptorTypes_.size() ); + pDescriptorTypes = descriptorTypes_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default; +#else + bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); + } + + bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t descriptorTypeCount = {}; + const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes = {}; + }; + static_assert( sizeof( MutableDescriptorTypeListVALVE ) == sizeof( VkMutableDescriptorTypeListVALVE ), + "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); + + struct MutableDescriptorTypeCreateInfoVALVE + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eMutableDescriptorTypeCreateInfoVALVE; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE( + uint32_t mutableDescriptorTypeListCount_ = {}, + const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists_ = {} ) + VULKAN_HPP_NOEXCEPT + : mutableDescriptorTypeListCount( mutableDescriptorTypeListCount_ ) + , pMutableDescriptorTypeLists( pMutableDescriptorTypeLists_ ) + {} + + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE( MutableDescriptorTypeCreateInfoVALVE const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeCreateInfoVALVE( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeCreateInfoVALVE( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + mutableDescriptorTypeLists_ ) + : mutableDescriptorTypeListCount( static_cast( mutableDescriptorTypeLists_.size() ) ) + , pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() ) + {} +# endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + MutableDescriptorTypeCreateInfoVALVE & + operator=( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & + operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( MutableDescriptorTypeCreateInfoVALVE ) ); + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & + setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; + return *this; + } + + MutableDescriptorTypeCreateInfoVALVE & setPMutableDescriptorTypeLists( + const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; + return *this; + } + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeLists( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = static_cast( mutableDescriptorTypeLists_.size() ); + pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data(); + return *this; + } +#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) + + operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default; +#else + bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && + ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); + } + + bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoVALVE; + const void * pNext = {}; + uint32_t mutableDescriptorTypeListCount = {}; + const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists = {}; + }; + static_assert( sizeof( MutableDescriptorTypeCreateInfoVALVE ) == sizeof( VkMutableDescriptorTypeCreateInfoVALVE ), + "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = MutableDescriptorTypeCreateInfoVALVE; + }; + union PerformanceCounterResultKHR { PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const & rhs ) VULKAN_HPP_NOEXCEPT @@ -75236,6 +75524,96 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE + { + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( + VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ = {} ) VULKAN_HPP_NOEXCEPT + : mutableDescriptorType( mutableDescriptorType_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) + VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } +#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & + operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & + operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( static_cast( this ), &rhs, sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) ); + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & + setMutableDescriptorType( VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorType = mutableDescriptorType_; + return *this; + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default; +#else + bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); + } + + bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType = {}; + }; + static_assert( sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) == + sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE ), + "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + }; + struct PhysicalDevicePCIBusInfoPropertiesEXT { static const bool allowDuplicate = false; @@ -104074,6 +104452,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( + VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); + } +# else + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const + { + Result result = + static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( @@ -107478,6 +107876,46 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, + VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + return static_cast( + d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( pDisplay ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType::type + PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( + d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( + d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + ObjectRelease deleter( *this, d ); + return createResultValue( + result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter ); + } +# endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, @@ -108335,6 +108773,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -109175,6 +109629,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -110665,6 +111135,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ @@ -111113,7 +111586,10 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; - PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; #ifdef VK_USE_PLATFORM_WIN32_KHR PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -111252,6 +111728,10 @@ namespace VULKAN_HPP_NAMESPACE void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT { VkInstance instance = static_cast( instanceCpp ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkAcquireWinrtDisplayNV = + PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); @@ -111490,6 +111970,9 @@ namespace VULKAN_HPP_NAMESPACE vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );