mirror of
https://github.com/KhronosGroup/Vulkan-Hpp
synced 2024-11-08 13:40:08 +00:00
Introduce support of std::hash for vk-structures.
This commit is contained in:
parent
bc7a5b56b9
commit
3515c720fc
@ -591,6 +591,10 @@ By default, a little helper class ```DynamicLoader``` is used to dynamically loa
|
||||
|
||||
By default, the member ```m_mask``` of the ```Flags``` template class is private. This is to prevent accidentally setting a ```Flags``` with some inappropriate value. But it also prevents using a ```Flags```, or a structure holding a ```Flags```, to be used as a non-type template parameter. If you really need that functionality, and accept the reduced security, you can use this define to change the access specifier for m_mask from private to public, which allows using a ```Flags``` as a non-type template parameter.
|
||||
|
||||
#### VULKAN_HPP_HASH_COMBINE
|
||||
|
||||
This define can be used to specify your own hash combiner function. In order to determine the hash of a vk-structure, the hashes of the members of that struct are to be combined. This is done by this define, which by default is identical to what the function ```boost::hash_combine()``` does. It gets the type of the to-be-combined value, the seed, which is the combined value up to that point, and finally the to-be-combined value. This hash calculation determines a "shallow" hash, as it takes the hashes of any pointer in a structure, and not the hash of a pointed-to value.
|
||||
|
||||
#### VULKAN_HPP_INLINE
|
||||
|
||||
This is set to be the compiler-dependent attribute used to mark functions as inline. If your compiler happens to need some different attribute, you can set this define accordingly before including vulkan.hpp.
|
||||
|
@ -695,7 +695,7 @@ std::string VulkanHppGenerator::generateHandles() const
|
||||
return str;
|
||||
}
|
||||
|
||||
std::string VulkanHppGenerator::generateHashStructures() const
|
||||
std::string VulkanHppGenerator::generateHandleHashStructures() const
|
||||
{
|
||||
const std::string hashesTemplate = R"(
|
||||
//=======================
|
||||
@ -705,24 +705,14 @@ std::string VulkanHppGenerator::generateHashStructures() const
|
||||
${hashes}
|
||||
)";
|
||||
|
||||
// start with the hash on Flags<BitType>
|
||||
std::string hashes = R"(
|
||||
template <typename BitType> struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
|
||||
{
|
||||
std::size_t operator()(VULKAN_HPP_NAMESPACE::Flags<BitType> const& flags) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<typename std::underlying_type<BitType>::type>{}(static_cast<typename std::underlying_type<BitType>::type>(flags));
|
||||
}
|
||||
};
|
||||
)";
|
||||
|
||||
std::string hashes;
|
||||
for ( auto const & feature : m_features )
|
||||
{
|
||||
hashes += generateHashStructures( feature.second.requireData, feature.first );
|
||||
hashes += generateHandleHashStructures( feature.second.requireData, feature.first );
|
||||
}
|
||||
for ( auto const & extIt : m_extensionsByNumber )
|
||||
{
|
||||
hashes += generateHashStructures( extIt.second->second.requireData, extIt.second->first );
|
||||
hashes += generateHandleHashStructures( extIt.second->second.requireData, extIt.second->first );
|
||||
}
|
||||
return replaceWithMap( hashesTemplate, { { "hashes", hashes } } );
|
||||
}
|
||||
@ -1804,9 +1794,7 @@ void VulkanHppGenerator::checkStructMemberCorrectness( std::string const &
|
||||
// check that there's a 1-1 connection between the specified selections and the values of that enum
|
||||
if ( !member.selector.empty() )
|
||||
{
|
||||
std::string const & selector = member.selector;
|
||||
auto selectorIt = std::find_if(
|
||||
members.begin(), members.end(), [&selector]( MemberData const & md ) { return md.name == selector; } );
|
||||
auto selectorIt = findStructMemberIt( member.selector, members );
|
||||
assert( selectorIt != members.end() );
|
||||
auto selectorEnumIt = m_enums.find( selectorIt->type.type );
|
||||
assert( selectorEnumIt != m_enums.end() );
|
||||
@ -2027,16 +2015,10 @@ std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
|
||||
if ( pd.type.type != destructorParam.type.type )
|
||||
{
|
||||
// check if the destructor param type equals a structure member type
|
||||
auto isStructureMemberType = [&destructorParam]( MemberData const & md )
|
||||
{
|
||||
return md.type.type == destructorParam.type.type;
|
||||
};
|
||||
|
||||
auto structureIt = m_structures.find( pd.type.type );
|
||||
return ( structureIt != m_structures.end() ) &&
|
||||
( std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
isStructureMemberType ) != structureIt->second.members.end() );
|
||||
( findStructMemberItByType( destructorParam.type.type, structureIt->second.members ) !=
|
||||
structureIt->second.members.end() );
|
||||
}
|
||||
return true;
|
||||
};
|
||||
@ -2247,6 +2229,21 @@ std::string VulkanHppGenerator::findBaseName( std::string
|
||||
return baseName;
|
||||
}
|
||||
|
||||
std::vector<VulkanHppGenerator::MemberData>::const_iterator
|
||||
VulkanHppGenerator::findStructMemberIt( std::string const & name, std::vector<MemberData> const & memberData ) const
|
||||
{
|
||||
return std::find_if(
|
||||
memberData.begin(), memberData.end(), [&name]( MemberData const & md ) { return md.name == name; } );
|
||||
}
|
||||
|
||||
std::vector<VulkanHppGenerator::MemberData>::const_iterator
|
||||
VulkanHppGenerator::findStructMemberItByType( std::string const & type,
|
||||
std::vector<MemberData> const & memberData ) const
|
||||
{
|
||||
return std::find_if(
|
||||
memberData.begin(), memberData.end(), [&type]( MemberData const & md ) { return md.type.type == type; } );
|
||||
}
|
||||
|
||||
std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamData> const & params,
|
||||
std::set<size_t> const & skippedParams,
|
||||
std::set<size_t> const & singularParams,
|
||||
@ -7366,8 +7363,8 @@ std::string VulkanHppGenerator::generateHandleEmpty( HandleData const & handleDa
|
||||
return str;
|
||||
}
|
||||
|
||||
std::string VulkanHppGenerator::generateHashStructures( std::vector<RequireData> const & requireData,
|
||||
std::string const & title ) const
|
||||
std::string VulkanHppGenerator::generateHandleHashStructures( std::vector<RequireData> const & requireData,
|
||||
std::string const & title ) const
|
||||
{
|
||||
const std::string hashTemplate = R"(
|
||||
template <> struct hash<VULKAN_HPP_NAMESPACE::${type}>
|
||||
@ -10607,10 +10604,8 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorInitializationList(
|
||||
auto structureIt = m_structures.find( constructorParam.type.type );
|
||||
if ( structureIt != m_structures.end() )
|
||||
{
|
||||
auto structureMemberIt = std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
[&destructorParam]( MemberData const & md )
|
||||
{ return md.type.type == destructorParam.type.type; } );
|
||||
auto structureMemberIt =
|
||||
findStructMemberItByType( destructorParam.type.type, structureIt->second.members );
|
||||
if ( structureMemberIt != structureIt->second.members.end() )
|
||||
{
|
||||
assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() &&
|
||||
@ -10936,10 +10931,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVector(
|
||||
assert( lenIt != constructorIt->second.params.end() );
|
||||
auto structureIt = m_structures.find( lenIt->type.type );
|
||||
assert( structureIt != m_structures.end() );
|
||||
assert( std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
[&lenParts]( MemberData const & md )
|
||||
{ return md.name == lenParts[1]; } ) != structureIt->second.members.end() );
|
||||
assert( isStructMember( lenParts[1], structureIt->second.members ) );
|
||||
assert( constructorIt->second.successCodes.size() == 1 );
|
||||
#endif
|
||||
vectorSize = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + lenParts[1];
|
||||
@ -11468,10 +11460,7 @@ std::string VulkanHppGenerator::generateRAIIHandleSingularConstructorArguments(
|
||||
auto structureIt = m_structures.find( constructorParam.type.type );
|
||||
if ( structureIt != m_structures.end() )
|
||||
{
|
||||
auto memberIt = std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
[&destructorParam]( MemberData const & md )
|
||||
{ return md.type.type == destructorParam.type.type; } );
|
||||
auto memberIt = findStructMemberItByType( destructorParam.type.type, structureIt->second.members );
|
||||
if ( memberIt != structureIt->second.members.end() )
|
||||
{
|
||||
#if !defined( NDEBUG )
|
||||
@ -11782,8 +11771,7 @@ std::string VulkanHppGenerator::generateStructConstructorsEnhanced(
|
||||
for ( auto const & mit : memberIts )
|
||||
{
|
||||
std::string lenName = ( mit->len.front() == "codeSize / 4" ) ? "codeSize" : mit->len.front();
|
||||
auto lenIt = std::find_if(
|
||||
structData.second.members.begin(), mit, [&lenName]( MemberData const & md ) { return md.name == lenName; } );
|
||||
auto lenIt = findStructMemberIt( lenName, structData.second.members );
|
||||
assert( lenIt != mit );
|
||||
lenIts[lenIt].push_back( mit );
|
||||
}
|
||||
@ -11907,6 +11895,44 @@ std::string VulkanHppGenerator::generateStructConstructorArgument( bool
|
||||
return str;
|
||||
}
|
||||
|
||||
std::string VulkanHppGenerator::generateStructHashSum( std::string const & structName,
|
||||
std::vector<MemberData> const & members ) const
|
||||
{
|
||||
std::string hashSum;
|
||||
for ( auto const & member : members )
|
||||
{
|
||||
if ( !member.arraySizes.empty() )
|
||||
{
|
||||
assert( member.arraySizes.size() < 3 );
|
||||
std::string memberType = member.type.compose( "VULKAN_HPP_NAMESPACE" );
|
||||
hashSum += " for ( size_t i = 0; i < " + member.arraySizes[0] + "; ++i )\n";
|
||||
hashSum += " {\n";
|
||||
if ( member.arraySizes.size() == 1 )
|
||||
{
|
||||
hashSum +=
|
||||
" VULKAN_HPP_HASH_COMBINE( " + memberType + ", seed, " + structName + "." + member.name + "[i] );\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
hashSum += " for ( size_t j=0; j < " + member.arraySizes[1] + "; ++j )\n";
|
||||
hashSum += " {\n";
|
||||
hashSum += " VULKAN_HPP_HASH_COMBINE( " + memberType + ", seed, " + structName + "." + member.name +
|
||||
"[i][j] );\n";
|
||||
hashSum += " }\n";
|
||||
}
|
||||
hashSum += " }\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string memberType =
|
||||
member.bitCount.empty() ? member.type.compose( "VULKAN_HPP_NAMESPACE" ) : member.type.type;
|
||||
hashSum += " VULKAN_HPP_HASH_COMBINE( " + memberType + ", seed, " + structName + "." + member.name + " );\n";
|
||||
}
|
||||
}
|
||||
assert( !hashSum.empty() );
|
||||
return hashSum.substr( 0, hashSum.size() - 1 );
|
||||
}
|
||||
|
||||
std::string VulkanHppGenerator::generateStructure( std::pair<std::string, StructureData> const & structure ) const
|
||||
{
|
||||
auto [enter, leave] = generateProtection(
|
||||
@ -11944,22 +11970,22 @@ std::string VulkanHppGenerator::generateStructure( std::pair<std::string, Struct
|
||||
std::string members, sTypeValue;
|
||||
std::tie( members, sTypeValue ) = generateStructMembers( structure, " " );
|
||||
|
||||
static const std::string structureTemplate = R"( struct ${structureName}
|
||||
static const std::string structureTemplate = R"( struct ${structureType}
|
||||
{
|
||||
using NativeType = Vk${structureName};
|
||||
using NativeType = Vk${structureType};
|
||||
|
||||
${allowDuplicate}
|
||||
${structureType}
|
||||
${typeValue}
|
||||
${constructorAndSetters}
|
||||
|
||||
operator ${vkName} const &() const VULKAN_HPP_NOEXCEPT
|
||||
operator Vk${structureType} const &() const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return *reinterpret_cast<const ${vkName}*>( this );
|
||||
return *reinterpret_cast<const Vk${structureType}*>( this );
|
||||
}
|
||||
|
||||
operator ${vkName} &() VULKAN_HPP_NOEXCEPT
|
||||
operator Vk${structureType} &() VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return *reinterpret_cast<${vkName}*>( this );
|
||||
return *reinterpret_cast<Vk${structureType}*>( this );
|
||||
}
|
||||
|
||||
${compareOperators}
|
||||
@ -11967,28 +11993,27 @@ ${compareOperators}
|
||||
public:
|
||||
${members}
|
||||
};
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::${structureName} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::${structureName}>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::${structureName}>::value, "${structureName} is not nothrow_move_constructible!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::${structureType} ) == sizeof( Vk${structureType} ), "struct and wrapper have different size!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::${structureType}>::value, "struct wrapper is not a standard layout!" );
|
||||
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::${structureType}>::value, "${structureType} is not nothrow_move_constructible!" );
|
||||
)";
|
||||
|
||||
std::string structureName = stripPrefix( structure.first, "Vk" );
|
||||
std::string allowDuplicate, structureType;
|
||||
std::string structureType = stripPrefix( structure.first, "Vk" );
|
||||
std::string allowDuplicate, typeValue;
|
||||
if ( !sTypeValue.empty() )
|
||||
{
|
||||
allowDuplicate = std::string( " static const bool allowDuplicate = " ) +
|
||||
( structure.second.allowDuplicate ? "true;" : "false;" );
|
||||
structureType =
|
||||
typeValue =
|
||||
" static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::" + sTypeValue + ";\n";
|
||||
}
|
||||
str += replaceWithMap( structureTemplate,
|
||||
{ { "allowDuplicate", allowDuplicate },
|
||||
{ "structureName", structureName },
|
||||
{ "structureType", structureType },
|
||||
{ "constructorAndSetters", constructorAndSetters },
|
||||
{ "vkName", structure.first },
|
||||
{ "compareOperators", compareOperators },
|
||||
{ "members", members } } );
|
||||
{ "members", members },
|
||||
{ "structureType", structureType },
|
||||
{ "typeValue", typeValue } } );
|
||||
|
||||
if ( !sTypeValue.empty() )
|
||||
{
|
||||
@ -11996,10 +12021,10 @@ ${members}
|
||||
template <>
|
||||
struct CppType<StructureType, StructureType::${sTypeValue}>
|
||||
{
|
||||
using Type = ${structureName};
|
||||
using Type = ${structureType};
|
||||
};
|
||||
)";
|
||||
str += replaceWithMap( cppTypeTemplate, { { "sTypeValue", sTypeValue }, { "structureName", structureName } } );
|
||||
str += replaceWithMap( cppTypeTemplate, { { "sTypeValue", sTypeValue }, { "structureType", structureType } } );
|
||||
}
|
||||
|
||||
auto aliasIt = m_structureAliasesInverse.find( structure.first );
|
||||
@ -12007,10 +12032,36 @@ ${members}
|
||||
{
|
||||
for ( std::string const & alias : aliasIt->second )
|
||||
{
|
||||
str += " using " + stripPrefix( alias, "Vk" ) + " = " + structureName + ";\n";
|
||||
str += " using " + stripPrefix( alias, "Vk" ) + " = " + structureType + ";\n";
|
||||
}
|
||||
}
|
||||
|
||||
if ( !containsUnion( structure.first ) )
|
||||
{
|
||||
static const std::string hashTemplate = R"(
|
||||
} // VULKAN_HPP_NAMESPACE
|
||||
|
||||
template <> struct std::hash<VULKAN_HPP_NAMESPACE::${structureType}>
|
||||
{
|
||||
std::size_t operator()(VULKAN_HPP_NAMESPACE::${structureType} const & ${structureName}) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
std::size_t seed = 0;
|
||||
${hashSum}
|
||||
return seed;
|
||||
}
|
||||
};
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
)";
|
||||
|
||||
std::string structureName = startLowerCase( structureType );
|
||||
str += replaceWithMap( hashTemplate,
|
||||
{ { "hashSum", generateStructHashSum( structureName, structure.second.members ) },
|
||||
{ "structureName", structureName },
|
||||
{ "structureType", structureType } } );
|
||||
}
|
||||
|
||||
str += leave;
|
||||
return str;
|
||||
}
|
||||
@ -12251,8 +12302,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const &
|
||||
lenValue += " * sizeof(T)";
|
||||
}
|
||||
|
||||
auto lenMember = std::find_if(
|
||||
memberData.begin(), memberData.end(), [&lenName]( MemberData const & md ) { return md.name == lenName; } );
|
||||
auto lenMember = findStructMemberIt( lenName, memberData );
|
||||
assert( lenMember != memberData.end() && lenMember->type.prefix.empty() && lenMember->type.postfix.empty() );
|
||||
if ( lenMember->type.type != "size_t" )
|
||||
{
|
||||
@ -12388,11 +12438,7 @@ std::string VulkanHppGenerator::generateUnion( std::pair<std::string, StructureD
|
||||
// constructor.
|
||||
if ( memberIt->type.type == "VkBool32" )
|
||||
{
|
||||
if ( std::find_if( structure.second.members.begin(),
|
||||
structure.second.members.end(),
|
||||
[]( MemberData const & member ) {
|
||||
return member.type.type == std::string( "uint32_t" );
|
||||
} ) != structure.second.members.end() )
|
||||
if ( findStructMemberItByType( "uint32_t", structure.second.members ) != structure.second.members.end() )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@ -12769,10 +12815,7 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, std::vec
|
||||
#if !defined( NDEBUG )
|
||||
auto structureIt = m_structures.find( paramIt->type.type );
|
||||
assert( structureIt != m_structures.end() );
|
||||
assert( std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
[&n = nameParts[1]]( MemberData const & md )
|
||||
{ return md.name == n; } ) != structureIt->second.members.end() );
|
||||
assert( isStructMember( nameParts[1], structureIt->second.members ) );
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
@ -12794,10 +12837,7 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, ParamDat
|
||||
#if !defined( NDEBUG )
|
||||
auto structureIt = m_structures.find( param.type.type );
|
||||
assert( structureIt != m_structures.end() );
|
||||
assert( std::find_if( structureIt->second.members.begin(),
|
||||
structureIt->second.members.end(),
|
||||
[&n = nameParts[1]]( MemberData const & md )
|
||||
{ return md.name == n; } ) != structureIt->second.members.end() );
|
||||
assert( isStructMember( nameParts[1], structureIt->second.members ) );
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
@ -12832,6 +12872,11 @@ bool VulkanHppGenerator::isParam( std::string const & name, std::vector<ParamDat
|
||||
params.end();
|
||||
}
|
||||
|
||||
bool VulkanHppGenerator::isStructMember( std::string const & name, std::vector<MemberData> const & memberData ) const
|
||||
{
|
||||
return findStructMemberIt( name, memberData ) != memberData.end();
|
||||
}
|
||||
|
||||
bool VulkanHppGenerator::isStructureChainAnchor( std::string const & type ) const
|
||||
{
|
||||
if ( beginsWith( type, "Vk" ) )
|
||||
@ -13872,8 +13917,8 @@ void VulkanHppGenerator::readFormatsFormat( tinyxml2::XMLElement const * element
|
||||
{
|
||||
check( !componentIt->planeIndex.empty(), line, "component is expected to have a planeIndex" );
|
||||
}
|
||||
size_t planeCount = 1 + std::stoi( it->second.components.back().planeIndex );
|
||||
check( it->second.planes.size() == planeCount,
|
||||
size_t planeCount = 1 + std::stoi( it->second.components.back().planeIndex );
|
||||
check( it->second.planes.size() == planeCount,
|
||||
line,
|
||||
"number of planes does not fit to largest planeIndex of the components" );
|
||||
}
|
||||
@ -14341,9 +14386,7 @@ void VulkanHppGenerator::readSPIRVCapabilitiesSPIRVCapabilityEnableProperty(
|
||||
auto propertyIt = m_structures.find( property );
|
||||
check(
|
||||
propertyIt != m_structures.end(), xmlLine, "unknown property <" + property + "> specified for SPIR-V capability" );
|
||||
auto memberIt = std::find_if( propertyIt->second.members.begin(),
|
||||
propertyIt->second.members.end(),
|
||||
[&member]( MemberData const & md ) { return md.name == member; } );
|
||||
auto memberIt = findStructMemberIt( member, propertyIt->second.members );
|
||||
check( memberIt != propertyIt->second.members.end(),
|
||||
xmlLine,
|
||||
"unknown member <" + member + "> specified for SPIR-V capability" );
|
||||
@ -15231,10 +15274,7 @@ void VulkanHppGenerator::readTypesTypeStructMember( tinyxml2::XMLElement const *
|
||||
check( !memberData.len.empty() && ( memberData.len.size() <= 2 ),
|
||||
line,
|
||||
"member attribute <len> holds unknown number of data: " + std::to_string( memberData.len.size() ) );
|
||||
auto lenMember =
|
||||
std::find_if( members.begin(),
|
||||
members.end(),
|
||||
[&memberData]( MemberData const & md ) { return ( md.name == memberData.len[0] ); } );
|
||||
auto lenMember = findStructMemberIt( memberData.len[0], members );
|
||||
check( lenMember != members.end() || ( memberData.len[0] == "null-terminated" ),
|
||||
line,
|
||||
"member attribute <len> holds unknown value <" + memberData.len[0] + ">" );
|
||||
@ -15273,11 +15313,11 @@ void VulkanHppGenerator::readTypesTypeStructMember( tinyxml2::XMLElement const *
|
||||
}
|
||||
else if ( attribute.first == "selector" )
|
||||
{
|
||||
memberData.selector = attribute.second;
|
||||
std::string const & selector = memberData.selector;
|
||||
auto selectorIt = std::find_if(
|
||||
members.begin(), members.end(), [selector]( MemberData const & md ) { return md.name == selector; } );
|
||||
check( selectorIt != members.end(), line, "member attribute <selector> holds unknown value <" + selector + ">" );
|
||||
memberData.selector = attribute.second;
|
||||
auto selectorIt = findStructMemberIt( memberData.selector, members );
|
||||
check( selectorIt != members.end(),
|
||||
line,
|
||||
"member attribute <selector> holds unknown value <" + memberData.selector + ">" );
|
||||
check( m_enums.find( selectorIt->type.type ) != m_enums.end(),
|
||||
line,
|
||||
"member attribute <selector> references unknown enum type <" + selectorIt->type.type + ">" );
|
||||
@ -15323,10 +15363,7 @@ void VulkanHppGenerator::readTypesTypeStructMemberName( tinyxml2::XMLElement con
|
||||
checkElements( line, getChildElements( element ), {}, {} );
|
||||
|
||||
std::string name = element->GetText();
|
||||
check( std::find_if( members.begin(), members.end(), [&name]( MemberData const & md ) { return md.name == name; } ) ==
|
||||
members.end(),
|
||||
line,
|
||||
"structure member name <" + name + "> already used" );
|
||||
check( !isStructMember( name, members ), line, "structure member name <" + name + "> already used" );
|
||||
|
||||
memberData.name = name;
|
||||
std::tie( memberData.arraySizes, memberData.bitCount ) = readModifiers( element->NextSibling() );
|
||||
@ -16716,6 +16753,18 @@ int main( int argc, char ** argv )
|
||||
{
|
||||
return flags.operator^( bit );
|
||||
}
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
template <typename BitType> struct std::hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
|
||||
{
|
||||
std::size_t operator()(VULKAN_HPP_NAMESPACE::Flags<BitType> const& flags) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<typename std::underlying_type<BitType>::type>{}(static_cast<typename std::underlying_type<BitType>::type>(flags));
|
||||
}
|
||||
};
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
)";
|
||||
|
||||
static const std::string classObjectDestroy = R"(
|
||||
@ -17430,6 +17479,11 @@ int main( int argc, char ** argv )
|
||||
# define VULKAN_HPP_NAMESPACE vk
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_HASH_COMBINE )
|
||||
# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \
|
||||
seed ^= std::hash<std::remove_const<valueType>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
|
||||
#endif
|
||||
|
||||
#define VULKAN_HPP_STRINGIFY2( text ) #text
|
||||
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
|
||||
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
|
||||
@ -18162,6 +18216,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
str += generator.generateHandles();
|
||||
str += R"(
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
namespace std
|
||||
{)";
|
||||
str += generator.generateHandleHashStructures();
|
||||
str += R"(} // namespace std
|
||||
#endif
|
||||
)";
|
||||
writeToFile( str, VULKAN_HANDLES_HPP_FILE );
|
||||
@ -18259,12 +18318,6 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
str += generator.generateDispatchLoaderDynamic();
|
||||
str +=
|
||||
"} // namespace VULKAN_HPP_NAMESPACE\n"
|
||||
"\n"
|
||||
"namespace std\n"
|
||||
"{\n";
|
||||
str += generator.generateHashStructures();
|
||||
str +=
|
||||
"} // namespace std\n"
|
||||
"#endif\n";
|
||||
|
||||
writeToFile( str, VULKAN_HPP_FILE );
|
||||
|
@ -33,7 +33,7 @@ public:
|
||||
std::string generateEnums() const;
|
||||
std::string generateFormatTraits() const;
|
||||
std::string generateHandles() const;
|
||||
std::string generateHashStructures() const;
|
||||
std::string generateHandleHashStructures() const;
|
||||
std::string generateIndexTypeTraits() const;
|
||||
std::string generateRAIICommandDefinitions() const;
|
||||
std::string generateRAIIDispatchers() const;
|
||||
@ -435,15 +435,19 @@ private:
|
||||
std::map<size_t, size_t> determineVectorParamIndices( std::vector<ParamData> const & params ) const;
|
||||
void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
|
||||
std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const;
|
||||
std::string generateArgumentListEnhanced( std::vector<ParamData> const & params,
|
||||
std::set<size_t> const & skippedParams,
|
||||
std::set<size_t> const & singularParams,
|
||||
bool definition,
|
||||
bool withAllocators,
|
||||
bool structureChain,
|
||||
bool withDispatcher ) const;
|
||||
std::string generateArgumentListStandard( std::vector<ParamData> const & params,
|
||||
std::set<size_t> const & skippedParams ) const;
|
||||
std::vector<MemberData>::const_iterator findStructMemberIt( std::string const & name,
|
||||
std::vector<MemberData> const & memberData ) const;
|
||||
std::vector<MemberData>::const_iterator findStructMemberItByType( std::string const & type,
|
||||
std::vector<MemberData> const & memberData ) const;
|
||||
std::string generateArgumentListEnhanced( std::vector<ParamData> const & params,
|
||||
std::set<size_t> const & skippedParams,
|
||||
std::set<size_t> const & singularParams,
|
||||
bool definition,
|
||||
bool withAllocators,
|
||||
bool structureChain,
|
||||
bool withDispatcher ) const;
|
||||
std::string generateArgumentListStandard( std::vector<ParamData> const & params,
|
||||
std::set<size_t> const & skippedParams ) const;
|
||||
std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
|
||||
std::string generateBitmasks( std::vector<RequireData> const & requireData,
|
||||
std::set<std::string> & listedBitmasks,
|
||||
@ -887,7 +891,8 @@ private:
|
||||
std::string generateHandleDependencies( std::pair<std::string, HandleData> const & handle,
|
||||
std::set<std::string> & listedHandles ) const;
|
||||
std::string generateHandleEmpty( HandleData const & handleData ) const;
|
||||
std::string generateHashStructures( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
||||
std::string generateHandleHashStructures( std::vector<RequireData> const & requireData,
|
||||
std::string const & title ) const;
|
||||
std::string
|
||||
generateLenInitializer( std::vector<MemberData>::const_iterator mit,
|
||||
std::map<std::vector<MemberData>::const_iterator,
|
||||
@ -1213,6 +1218,7 @@ private:
|
||||
std::string generateStructConstructorsEnhanced( std::pair<std::string, StructureData> const & structData ) const;
|
||||
std::string
|
||||
generateStructConstructorArgument( bool listedArgument, MemberData const & memberData, bool withDefault ) const;
|
||||
std::string generateStructHashSum( std::string const & structName, std::vector<MemberData> const & members ) const;
|
||||
std::string generateStructure( std::pair<std::string, StructureData> const & structure ) const;
|
||||
std::string generateStructExtendsStructs( std::vector<RequireData> const & requireData,
|
||||
std::set<std::string> & listedStructs,
|
||||
@ -1248,6 +1254,7 @@ private:
|
||||
bool isMultiSuccessCodeConstructor(
|
||||
std::vector<std::map<std::string, CommandData>::const_iterator> const & constructorIts ) const;
|
||||
bool isParam( std::string const & name, std::vector<ParamData> const & params ) const;
|
||||
bool isStructMember( std::string const & name, std::vector<MemberData> const & memberData ) const;
|
||||
bool isStructureChainAnchor( std::string const & type ) const;
|
||||
std::pair<bool, std::map<size_t, std::vector<size_t>>>
|
||||
needsVectorSizeCheck( std::map<size_t, size_t> const & vectorParamIndices ) const;
|
||||
|
@ -48,6 +48,28 @@ int main( int /*argc*/, char ** /*argv*/ )
|
||||
|
||||
std::unordered_map<vk::Instance, size_t> umap;
|
||||
umap[*instance] = 1;
|
||||
|
||||
vk::AabbPositionsKHR aabb0, aabb1;
|
||||
auto h3 = std::hash<vk::AabbPositionsKHR>{}( aabb0 );
|
||||
auto h4 = std::hash<vk::AabbPositionsKHR>{}( aabb1 );
|
||||
assert( h3 == h4 );
|
||||
|
||||
aabb0.minX = 1.0f;
|
||||
auto h5 = std::hash<vk::AabbPositionsKHR>{}( aabb0 );
|
||||
assert( h3 != h5 );
|
||||
|
||||
std::unordered_set<vk::AabbPositionsKHR> aabbSet;
|
||||
aabbSet.insert( aabb0 );
|
||||
|
||||
std::unordered_map<vk::AabbPositionsKHR, size_t> aabbMap;
|
||||
aabbMap[aabb0] = 1;
|
||||
|
||||
vk::AccelerationStructureInstanceKHR asi;
|
||||
asi.instanceCustomIndex = 1;
|
||||
asi.mask = 2;
|
||||
asi.instanceShaderBindingTableRecordOffset = 3;
|
||||
asi.flags = 4;
|
||||
auto h6 = std::hash<vk::AccelerationStructureInstanceKHR>{}( asi );
|
||||
}
|
||||
catch ( vk::SystemError const & err )
|
||||
{
|
||||
|
@ -234,6 +234,11 @@ static_assert( VK_HEADER_VERSION == 201, "Wrong VK_HEADER_VERSION!" );
|
||||
# define VULKAN_HPP_NAMESPACE vk
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_HASH_COMBINE )
|
||||
# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \
|
||||
seed ^= std::hash<std::remove_const<valueType>::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 )
|
||||
#endif
|
||||
|
||||
#define VULKAN_HPP_STRINGIFY2( text ) #text
|
||||
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
|
||||
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
|
||||
@ -813,7 +818,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
return flags.operator^( bit );
|
||||
}
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
template <typename BitType>
|
||||
struct std::hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<typename std::underlying_type<BitType>::type>{}(
|
||||
static_cast<typename std::underlying_type<BitType>::type>( flags ) );
|
||||
}
|
||||
};
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
template <typename RefType>
|
||||
class Optional
|
||||
{
|
||||
@ -14208,486 +14226,4 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
};
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
namespace std
|
||||
{
|
||||
//=======================
|
||||
//=== HASH structures ===
|
||||
//=======================
|
||||
|
||||
template <typename BitType>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<typename std::underlying_type<BitType>::type>{}(
|
||||
static_cast<typename std::underlying_type<BitType>::type>( flags ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_VERSION_1_0 ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Instance>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Device>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Queue>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Fence>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Event>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Buffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BufferView>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Image>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ImageView>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Sampler>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorUpdateTemplate>{}(
|
||||
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_surface ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_swapchain ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_display ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_debug_report ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_KHR_video_queue ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkVideoSessionParametersKHR>{}(
|
||||
static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
|
||||
}
|
||||
};
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_debug_utils ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_acceleration_structure ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkAccelerationStructureKHR>{}(
|
||||
static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_validation_cache ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkAccelerationStructureNV>{}(
|
||||
static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_INTEL_performance_query ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPerformanceConfigurationINTEL>{}(
|
||||
static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_deferred_host_operations ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_NV_device_generated_commands ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkIndirectCommandsLayoutNV>{}(
|
||||
static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_private_data ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBufferCollectionFUCHSIA>{}(
|
||||
static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
|
||||
}
|
||||
};
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
} // namespace std
|
||||
#endif
|
||||
|
@ -14531,4 +14531,476 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
namespace std
|
||||
{
|
||||
//=======================
|
||||
//=== HASH structures ===
|
||||
//=======================
|
||||
|
||||
//=== VK_VERSION_1_0 ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Instance>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Device>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Queue>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Fence>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkFence>{}( static_cast<VkFence>( fence ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Event>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Buffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BufferView>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Image>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkImage>{}( static_cast<VkImage>( image ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ImageView>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Sampler>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_VERSION_1_1 ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDescriptorUpdateTemplate>{}(
|
||||
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_surface ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_swapchain ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_display ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_debug_report ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
||||
//=== VK_KHR_video_queue ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkVideoSessionParametersKHR>{}(
|
||||
static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) );
|
||||
}
|
||||
};
|
||||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) );
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_debug_utils ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_acceleration_structure ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkAccelerationStructureKHR>{}(
|
||||
static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_validation_cache ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_NV_ray_tracing ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkAccelerationStructureNV>{}(
|
||||
static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_INTEL_performance_query ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL )
|
||||
const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPerformanceConfigurationINTEL>{}(
|
||||
static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_KHR_deferred_host_operations ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_NV_device_generated_commands ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkIndirectCommandsLayoutNV>{}(
|
||||
static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) );
|
||||
}
|
||||
};
|
||||
|
||||
//=== VK_EXT_private_data ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
|
||||
{
|
||||
std::size_t
|
||||
operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
//=== VK_FUCHSIA_buffer_collection ===
|
||||
|
||||
template <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
|
||||
{
|
||||
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const
|
||||
VULKAN_HPP_NOEXCEPT
|
||||
{
|
||||
return std::hash<VkBufferCollectionFUCHSIA>{}(
|
||||
static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) );
|
||||
}
|
||||
};
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
|
||||
} // namespace std
|
||||
#endif
|
||||
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user