AuroraMiddleware/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp synced 2024-11-30 07:30:07 +00:00
Code Issues Releases Wiki Activity

Merge pull request #838 from asuessenbach/164

Browse Source 
Update to VK_HEADER_VERSION 164.
This commit is contained in:
Andreas Süßenbach 2020-12-08 11:54:58 +01:00 committed by GitHub
commit 8e8fd27337
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 534 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 6a163aa97f8a3d1c186138bedbfb76ce117be8d1
Subproject commit fe9850767d00e46b230da6cfbc15eb86636017bd

67
VulkanHppGenerator.cpp
View File

@ -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<std::string, HandleData> 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 <descriptorSetCount> in structure <VkDescriptorSetAllocateInfo>" );
it->second.members[4].len = { it->second.members[3].name };
}
it->second.subStruct = determineSubStruct( *it );
m_extendedStructs.insert( structExtends.begin(), structExtends.end() );

527
vulkan/vulkan.hpp
View File

@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <compare>
#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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
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 VULKAN_HPP_NAMESPACE::DescriptorType> const &
descriptorTypes_ )
: descriptorTypeCount( static_cast<uint32_t>( 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<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const *>( &rhs );
return *this;
}
MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( static_cast<void *>( 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 VULKAN_HPP_NAMESPACE::DescriptorType> const &
descriptorTypes_ ) VULKAN_HPP_NOEXCEPT
{
descriptorTypeCount = static_cast<uint32_t>( descriptorTypes_.size() );
pDescriptorTypes = descriptorTypes_.data();
return *this;
}
#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE *>( this );
}
operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMutableDescriptorTypeListVALVE *>( 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<MutableDescriptorTypeListVALVE>::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 VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const &
mutableDescriptorTypeLists_ )
: mutableDescriptorTypeListCount( static_cast<uint32_t>( 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<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const *>( &rhs );
return *this;
}
MutableDescriptorTypeCreateInfoVALVE &
operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( static_cast<void *>( 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 VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const &
mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
{
mutableDescriptorTypeListCount = static_cast<uint32_t>( mutableDescriptorTypeLists_.size() );
pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data();
return *this;
}
#endif // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE *>( this );
}
operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE *>( 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<MutableDescriptorTypeCreateInfoVALVE>::value,
"struct wrapper is not a standard layout!" );
template <>
struct CppType<StructureType, StructureType::eMutableDescriptorTypeCreateInfoVALVE>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const *>( &rhs );
return *this;
}
PhysicalDeviceMutableDescriptorTypeFeaturesVALVE &
operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( static_cast<void *>( 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<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
}
operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( 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<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>::value,
"struct wrapper is not a standard layout!" );
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
{
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 <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV(
VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
}
# else
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
{
Result result =
static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( 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 <typename Dispatch>
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 <typename Dispatch>
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<Result>(
d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
}
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
{
VULKAN_HPP_NAMESPACE::DisplayKHR display;
Result result = static_cast<Result>(
d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
{
VULKAN_HPP_NAMESPACE::DisplayKHR display;
Result result = static_cast<Result>(
d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
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 <typename Dispatch>
VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
@ -108335,6 +108773,22 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>
{
enum
@ -109175,6 +109629,22 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>
{
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<VkInstance>( 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" ) );