mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Correct enum values for AccessFlagBits2KHR and PipelineStageFlagBits2KHR.

Browse Source 
All those values erroneously started with "e2", instead of just "e".
This commit is contained in:
asuessenbach 2021-04-13 12:25:10 +02:00
parent bd7a3e8ab7
commit d9bb97d9ec
3 changed files with 644 additions and 635 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

325
VulkanHppGenerator.cpp
View File

@ -405,8 +405,10 @@ std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_
std::set<size_t> skippedParams; std::set<size_t> skippedParams;
// the size-parameters of vector parameters are not explicitly used in the enhanced API // the size-parameters of vector parameters are not explicitly used in the enhanced API
std::for_each( std::for_each( vectorParamIndices.begin(),
vectorParamIndices.begin(), vectorParamIndices.end(), [&skippedParams]( std::pair<size_t, size_t> const & vp ) { vectorParamIndices.end(),
[&skippedParams]( std::pair<size_t, size_t> const & vp )
{
if ( vp.second != INVALID_INDEX ) if ( vp.second != INVALID_INDEX )
{ {
skippedParams.insert( vp.second ); skippedParams.insert( vp.second );
@ -475,29 +477,6 @@ std::string getEnumPostfix( std::string const & name, std::set<std::string> cons
return postfix; return postfix;
} }
std::string getEnumPrefix( int line, std::string const & name, bool bitmask )
{
std::string prefix;
if ( name == "VkResult" )
{
prefix = "VK_";
}
else if ( bitmask )
{
// for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
// end that with "Bit"
size_t pos = name.find( "FlagBits" );
check( pos != std::string::npos, line, "bitmask <" + name + "> does not contain <FlagBits>" );
prefix = toUpperCase( name.substr( 0, pos ) ) + "_";
}
else
{
// for a non-bitmask enum, convert the name to upper case
prefix = toUpperCase( name ) + "_";
}
return prefix;
}
std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags ) std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags )
{ {
// extract the tag from the name, which is supposed to look like VK_<tag>_<other> // extract the tag from the name, which is supposed to look like VK_<tag>_<other>
@ -726,23 +705,18 @@ std::string toString( std::vector<std::string> const & strings )
std::string toUpperCase( std::string const & name ) std::string toUpperCase( std::string const & name )
{ {
std::string convertedName; std::string convertedName;
convertedName.reserve( name.size() ); bool previousIsLowerCase = false;
bool previousIsDigit = false;
bool lowerOrDigit = false;
for ( auto c : name ) for ( auto c : name )
{ {
if ( islower( c ) || isdigit( c ) ) if ( ( isupper( c ) && ( previousIsLowerCase || previousIsDigit ) ) || ( isdigit( c ) && !previousIsDigit ) )
{
lowerOrDigit = true;
}
else if ( lowerOrDigit )
{ {
convertedName.push_back( '_' ); convertedName.push_back( '_' );
lowerOrDigit = false;
} }
convertedName.push_back( static_cast<char>( toupper( c ) ) ); convertedName.push_back( static_cast<char>( toupper( c ) ) );
previousIsLowerCase = !!islower( c );
previousIsDigit = !!isdigit( c );
} }
return convertedName; return convertedName;
} }
@ -873,9 +847,9 @@ void VulkanHppGenerator::appendArguments( std::string & str,
} }
else else
{ {
it = find_if( vectorParamIndices.begin(), vectorParamIndices.end(), [i]( std::pair<size_t, size_t> const & vpi ) { it = find_if( vectorParamIndices.begin(),
return vpi.second == i; vectorParamIndices.end(),
} ); [i]( std::pair<size_t, size_t> const & vpi ) { return vpi.second == i; } );
if ( it != vectorParamIndices.end() ) if ( it != vectorParamIndices.end() )
{ {
appendArgumentCount( str, it->first, commandData.params[it->first].name, templateParamIndex ); appendArgumentCount( str, it->first, commandData.params[it->first].name, templateParamIndex );
@ -1380,8 +1354,8 @@ void VulkanHppGenerator::appendCommand( std::string & str,
break; break;
case 2: case 2:
{ {
// two returns and two vectors! But one input vector, one output vector of the same size, and one output // two returns and two vectors! But one input vector, one output vector of the same size, and one
// value // output value
if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) && if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) &&
( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ) && ( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ) &&
( commandData.returnType == "VkResult" ) ) ( commandData.returnType == "VkResult" ) )
@ -2489,9 +2463,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
str += " enum class " + stripPrefix( enumData.first, "Vk" ); str += " enum class " + stripPrefix( enumData.first, "Vk" );
if ( enumData.second.isBitmask ) if ( enumData.second.isBitmask )
{ {
auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&enumData]( auto const & bitmask ) { auto bitmaskIt =
return bitmask.second.requirements == enumData.first; std::find_if( m_bitmasks.begin(),
} ); m_bitmasks.end(),
[&enumData]( auto const & bitmask ) { return bitmask.second.requirements == enumData.first; } );
assert( bitmaskIt != m_bitmasks.end() ); assert( bitmaskIt != m_bitmasks.end() );
str += " : " + bitmaskIt->first; str += " : " + bitmaskIt->first;
} }
@ -2524,10 +2499,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
{ {
assert( encounteredValue ); assert( encounteredValue );
// make sure to only list alias values that differ from all non-alias values // make sure to only list alias values that differ from all non-alias values
if ( std::find_if( if ( std::find_if( enumData.second.values.begin(),
enumData.second.values.begin(), enumData.second.values.end(), [&alias]( EnumValueData const & evd ) { enumData.second.values.end(),
return alias.second.second == evd.vkValue; [&alias]( EnumValueData const & evd )
} ) == enumData.second.values.end() ) { return alias.second.second == evd.vkValue; } ) == enumData.second.values.end() )
{ {
#if !defined( NDEBUG ) #if !defined( NDEBUG )
auto enumIt = auto enumIt =
@ -3150,10 +3125,10 @@ ${CppTypeFromDebugReportObjectTypeEXT}
assert( !handleData.second.objTypeEnum.empty() ); assert( !handleData.second.objTypeEnum.empty() );
enumIt = m_enums.find( "VkObjectType" ); enumIt = m_enums.find( "VkObjectType" );
assert( enumIt != m_enums.end() ); assert( enumIt != m_enums.end() );
valueIt = std::find_if( valueIt = std::find_if( enumIt->second.values.begin(),
enumIt->second.values.begin(), enumIt->second.values.end(), [&handleData]( EnumValueData const & evd ) { enumIt->second.values.end(),
return evd.vulkanValue == handleData.second.objTypeEnum; [&handleData]( EnumValueData const & evd )
} ); { return evd.vulkanValue == handleData.second.objTypeEnum; } );
assert( valueIt != enumIt->second.values.end() ); assert( valueIt != enumIt->second.values.end() );
str += replaceWithMap( templateString, str += replaceWithMap( templateString,
@ -3483,9 +3458,9 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
auto enumIt = m_enums.find( "VkObjectType" ); auto enumIt = m_enums.find( "VkObjectType" );
assert( enumIt != m_enums.end() ); assert( enumIt != m_enums.end() );
auto valueIt = auto valueIt =
std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), [&handle]( EnumValueData const & evd ) { std::find_if( enumIt->second.values.begin(),
return evd.vulkanValue == handle.second.objTypeEnum; enumIt->second.values.end(),
} ); [&handle]( EnumValueData const & evd ) { return evd.vulkanValue == handle.second.objTypeEnum; } );
assert( valueIt != enumIt->second.values.end() ); assert( valueIt != enumIt->second.values.end() );
std::string objTypeEnum = valueIt->vkValue; std::string objTypeEnum = valueIt->vkValue;
@ -3756,7 +3731,8 @@ bool VulkanHppGenerator::checkEquivalentSingularConstructor(
auto singularCommandIt = auto singularCommandIt =
std::find_if( constructorIts.begin(), std::find_if( constructorIts.begin(),
constructorIts.end(), constructorIts.end(),
[constructorIt, lenIt]( std::map<std::string, CommandData>::const_iterator it ) { [constructorIt, lenIt]( std::map<std::string, CommandData>::const_iterator it )
{
if ( it->second.params.size() + 1 != constructorIt->second.params.size() ) if ( it->second.params.size() + 1 != constructorIt->second.params.size() )
{ {
return false; return false;
@ -4030,8 +4006,8 @@ std::string VulkanHppGenerator::constructCallArgumentEnhanced( std::vector<Param
else if ( param.type.isNonConstPointer() && else if ( param.type.isNonConstPointer() &&
( specialPointerTypes.find( param.type.type ) == specialPointerTypes.end() ) ) ( specialPointerTypes.find( param.type.type ) == specialPointerTypes.end() ) )
{ {
// parameter is a non-const pointer (and none of the special pointer types, that are considered const-pointers, even // parameter is a non-const pointer (and none of the special pointer types, that are considered const-pointers,
// though they are not!) // even though they are not!)
std::string name = startLowerCase( stripPrefix( param.name, "p" ) ); std::string name = startLowerCase( stripPrefix( param.name, "p" ) );
if ( param.len.empty() ) if ( param.len.empty() )
{ {
@ -6675,9 +6651,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st
assert( typeIt->len == param.name ); assert( typeIt->len == param.name );
continue; continue;
} }
else if ( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { else if ( std::find_if( params.begin(),
return pd.len == param.name; params.end(),
} ) != params.end() ) [&param]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() )
{ {
// this is the len of an other parameter, which will be mapped to an ArrayProxy // this is the len of an other parameter, which will be mapped to an ArrayProxy
assert( param.type.isValue() && ( param.type.type == "uint32_t" ) ); assert( param.type.isValue() && ( param.type.type == "uint32_t" ) );
@ -6705,9 +6681,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st
} }
else else
{ {
assert( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { assert( std::find_if( params.begin(),
return pd.name == param.len; params.end(),
} ) != params.end() ); [&param]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() );
if ( singular ) if ( singular )
{ {
arguments += argumentType + " const & " + stripPluralS( argumentName ); arguments += argumentType + " const & " + stripPluralS( argumentName );
@ -6902,10 +6878,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList
assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() && assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() &&
!destructorParam.optional ); !destructorParam.optional );
initializationList += "m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( "; initializationList += "m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( ";
auto constructorParamIt = std::find_if( auto constructorParamIt = std::find_if( constructorIt->second.params.begin(),
constructorIt->second.params.begin(),
constructorIt->second.params.end(), constructorIt->second.params.end(),
[&destructorParam]( ParamData const & pd ) { return pd.type.type == destructorParam.type.type; } ); [&destructorParam]( ParamData const & pd )
{ return pd.type.type == destructorParam.type.type; } );
if ( constructorParamIt != constructorIt->second.params.end() ) if ( constructorParamIt != constructorIt->second.params.end() )
{ {
assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() && assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() &&
@ -6922,10 +6898,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList
auto structureIt = m_structures.find( constructorParam.type.type ); auto structureIt = m_structures.find( constructorParam.type.type );
if ( structureIt != m_structures.end() ) if ( structureIt != m_structures.end() )
{ {
auto structureMemberIt = std::find_if( auto structureMemberIt = std::find_if( structureIt->second.members.begin(),
structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&destructorParam]( MemberData const & md ) { return md.type.type == destructorParam.type.type; } ); [&destructorParam]( MemberData const & md )
{ return md.type.type == destructorParam.type.type; } );
if ( structureMemberIt != structureIt->second.members.end() ) if ( structureMemberIt != structureIt->second.members.end() )
{ {
assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() && assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() &&
@ -7147,8 +7123,8 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorVector(
assert( structureIt != m_structures.end() ); assert( structureIt != m_structures.end() );
assert( std::find_if( structureIt->second.members.begin(), assert( std::find_if( structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&lenParts]( MemberData const & md ) { return md.name == lenParts[1]; } ) != [&lenParts]( MemberData const & md )
structureIt->second.members.end() ); { return md.name == lenParts[1]; } ) != structureIt->second.members.end() );
assert( constructorIt->second.successCodes.size() == 1 ); assert( constructorIt->second.successCodes.size() == 1 );
vectorSize = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + lenParts[1]; vectorSize = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + lenParts[1];
} }
@ -7156,9 +7132,8 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorVector(
{ {
auto arrayIt = std::find_if( constructorIt->second.params.begin(), auto arrayIt = std::find_if( constructorIt->second.params.begin(),
constructorIt->second.params.end(), constructorIt->second.params.end(),
[&lenIt, &handleParamIt]( ParamData const & pd ) { [&lenIt, &handleParamIt]( ParamData const & pd )
return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name ); { return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name ); } );
} );
assert( arrayIt != constructorIt->second.params.end() ); assert( arrayIt != constructorIt->second.params.end() );
vectorSize = startLowerCase( stripPrefix( arrayIt->name, "p" ) ) + ".size()"; vectorSize = startLowerCase( stripPrefix( arrayIt->name, "p" ) ) + ".size()";
} }
@ -7357,9 +7332,10 @@ std::string
else else
{ {
assert( param.type.isConstPointer() ); assert( param.type.isConstPointer() );
assert( !param.len.empty() && ( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { assert( !param.len.empty() &&
return pd.name == param.len; ( std::find_if( params.begin(),
} ) != params.end() ) ); params.end(),
[&param]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ) );
arguments += "reinterpret_cast<" + param.type.type + " const *>( &" + argument + " )"; arguments += "reinterpret_cast<" + param.type.type + " const *>( &" + argument + " )";
} }
} }
@ -7367,9 +7343,9 @@ std::string
{ {
assert( ( param.type.type == "uint32_t" ) && param.type.isValue() && param.arraySizes.empty() && assert( ( param.type.type == "uint32_t" ) && param.type.isValue() && param.arraySizes.empty() &&
param.len.empty() && !param.optional ); param.len.empty() && !param.optional );
assert( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { assert( std::find_if( params.begin(),
return pd.len == param.name; params.end(),
} ) != params.end() ); [&param]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() );
arguments += "1"; arguments += "1";
} }
encounteredArgument = true; encounteredArgument = true;
@ -9677,10 +9653,10 @@ std::string VulkanHppGenerator::constructRAIIHandleSingularConstructorArguments(
auto structureIt = m_structures.find( constructorParam.type.type ); auto structureIt = m_structures.find( constructorParam.type.type );
if ( structureIt != m_structures.end() ) if ( structureIt != m_structures.end() )
{ {
auto memberIt = std::find_if( auto memberIt = std::find_if( structureIt->second.members.begin(),
structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&destructorParam]( MemberData const & md ) { return md.type.type == destructorParam.type.type; } ); [&destructorParam]( MemberData const & md )
{ return md.type.type == destructorParam.type.type; } );
if ( memberIt != structureIt->second.members.end() ) if ( memberIt != structureIt->second.members.end() )
{ {
#if !defined( NDEBUG ) #if !defined( NDEBUG )
@ -9970,10 +9946,10 @@ void VulkanHppGenerator::appendStructConstructorsEnhanced( std::string &
std::pair<std::string, StructureData> const & structData, std::pair<std::string, StructureData> const & structData,
std::string const & prefix ) const std::string const & prefix ) const
{ {
auto memberIts = auto memberIts = findAll( structData.second.members.begin(),
findAll( structData.second.members.begin(), structData.second.members.end(), []( MemberData const & md ) { structData.second.members.end(),
return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() ); []( MemberData const & md )
} ); { return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() ); } );
if ( !memberIts.empty() ) if ( !memberIts.empty() )
{ {
// maximal one member to be handled by an ArrayProxyNoTemporaries is of type void // maximal one member to be handled by an ArrayProxyNoTemporaries is of type void
@ -10450,9 +10426,10 @@ void VulkanHppGenerator::appendStructureChainValidation( std::string & str )
if ( itExtend == m_structures.end() ) if ( itExtend == m_structures.end() )
{ {
// look if the extendName acutally is an alias of some other structure // look if the extendName acutally is an alias of some other structure
itExtend = std::find_if( m_structures.begin(), m_structures.end(), [extendName]( auto const & sd ) { itExtend = std::find_if( m_structures.begin(),
return sd.second.aliases.find( extendName ) != sd.second.aliases.end(); m_structures.end(),
} ); [extendName]( auto const & sd )
{ return sd.second.aliases.find( extendName ) != sd.second.aliases.end(); } );
} }
if ( itExtend == m_structures.end() ) if ( itExtend == m_structures.end() )
{ {
@ -10538,10 +10515,10 @@ void VulkanHppGenerator::appendType( std::string & str, std::string const & type
auto handleIt = m_handles.find( typeName ); auto handleIt = m_handles.find( typeName );
if ( handleIt == m_handles.end() ) if ( handleIt == m_handles.end() )
{ {
handleIt = std::find_if( handleIt = std::find_if( m_handles.begin(),
m_handles.begin(), m_handles.end(), [&typeName]( std::pair<std::string, HandleData> const & hd ) { m_handles.end(),
return hd.second.alias == typeName; [&typeName]( std::pair<std::string, HandleData> const & hd )
} ); { return hd.second.alias == typeName; } );
assert( handleIt != m_handles.end() ); assert( handleIt != m_handles.end() );
if ( m_listedTypes.find( handleIt->first ) == m_listedTypes.end() ) if ( m_listedTypes.find( handleIt->first ) == m_listedTypes.end() )
{ {
@ -10560,10 +10537,10 @@ void VulkanHppGenerator::appendType( std::string & str, std::string const & type
auto structIt = m_structures.find( typeName ); auto structIt = m_structures.find( typeName );
if ( structIt == m_structures.end() ) if ( structIt == m_structures.end() )
{ {
structIt = std::find_if( structIt = std::find_if( m_structures.begin(),
m_structures.begin(), m_structures.end(), [&typeName]( std::pair<std::string, StructureData> const & sd ) { m_structures.end(),
return sd.second.aliases.find( typeName ) != sd.second.aliases.end(); [&typeName]( std::pair<std::string, StructureData> const & sd )
} ); { return sd.second.aliases.find( typeName ) != sd.second.aliases.end(); } );
assert( structIt != m_structures.end() ); assert( structIt != m_structures.end() );
if ( m_listedTypes.find( structIt->first ) == m_listedTypes.end() ) if ( m_listedTypes.find( structIt->first ) == m_listedTypes.end() )
{ {
@ -10605,7 +10582,8 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair<std::string,
{ {
// VkBool32 is aliased to uint32_t. Don't create a VkBool32 constructor if the union also contains a uint32_t // VkBool32 is aliased to uint32_t. Don't create a VkBool32 constructor if the union also contains a uint32_t
// constructor. // constructor.
auto compareBool32Alias = []( MemberData const & member ) { auto compareBool32Alias = []( MemberData const & member )
{
return member.type.type == std::string( "uint32_t" ); return member.type.type == std::string( "uint32_t" );
}; };
if ( member.type.type == "VkBool32" ) if ( member.type.type == "VkBool32" )
@ -10664,8 +10642,9 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair<std::string,
// the union member variables // the union member variables
// if there's at least one Vk... type in this union, check for unrestricted unions support // if there's at least one Vk... type in this union, check for unrestricted unions support
bool needsUnrestrictedUnions = bool needsUnrestrictedUnions = ( std::find_if( structure.second.members.begin(),
( std::find_if( structure.second.members.begin(), structure.second.members.end(), []( MemberData const & member ) { structure.second.members.end(),
[]( MemberData const & member ) {
return beginsWith( member.type.type, "Vk" ); return beginsWith( member.type.type, "Vk" );
} ) != structure.second.members.end() ); } ) != structure.second.members.end() );
if ( needsUnrestrictedUnions ) if ( needsUnrestrictedUnions )
@ -10743,8 +10722,8 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line,
// check that the aliasName is either a known enum value or at least a known alias // check that the aliasName is either a known enum value or at least a known alias
check( ( std::find_if( values.begin(), check( ( std::find_if( values.begin(),
values.end(), values.end(),
[&aliasName]( EnumValueData const & evd ) { return evd.vulkanValue == aliasName; } ) != [&aliasName]( EnumValueData const & evd )
values.end() ) || { return evd.vulkanValue == aliasName; } ) != values.end() ) ||
( aliases.find( aliasName ) != aliases.end() ), ( aliases.find( aliasName ) != aliases.end() ),
line, line,
"unknown enum alias <" + aliasName + ">" ); "unknown enum alias <" + aliasName + ">" );
@ -10757,9 +10736,8 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line,
// only list aliases that map to different vkNames // only list aliases that map to different vkNames
aliasIt = std::find_if( aliases.begin(), aliasIt = std::find_if( aliases.begin(),
aliases.end(), aliases.end(),
[&vkName]( std::pair<std::string, std::pair<std::string, std::string>> const & aliasEntry ) { [&vkName]( std::pair<std::string, std::pair<std::string, std::string>> const & aliasEntry )
return vkName == aliasEntry.second.second; { return vkName == aliasEntry.second.second; } );
} );
if ( aliasIt == aliases.end() ) if ( aliasIt == aliases.end() )
{ {
aliases.insert( std::make_pair( name, std::make_pair( aliasName, vkName ) ) ); aliases.insert( std::make_pair( name, std::make_pair( aliasName, vkName ) ) );
@ -10777,9 +10755,9 @@ void VulkanHppGenerator::EnumData::addEnumValue( int line,
{ {
std::string translatedName = createEnumValueName( valueName, prefix, postfix, bitmask, tag ); std::string translatedName = createEnumValueName( valueName, prefix, postfix, bitmask, tag );
auto it = std::find_if( values.begin(), values.end(), [&translatedName]( EnumValueData const & evd ) { auto it = std::find_if( values.begin(),
return evd.vkValue == translatedName; values.end(),
} ); [&translatedName]( EnumValueData const & evd ) { return evd.vkValue == translatedName; } );
if ( it == values.end() ) if ( it == values.end() )
{ {
values.emplace_back( line, valueName, translatedName, extension, bitpos ); values.emplace_back( line, valueName, translatedName, extension, bitpos );
@ -10929,9 +10907,8 @@ void VulkanHppGenerator::checkCorrectness()
{ {
check( std::find_if( m_handles.begin(), check( std::find_if( m_handles.begin(),
m_handles.end(), m_handles.end(),
[&objectTypeValue]( std::pair<std::string, HandleData> const & hd ) { [&objectTypeValue]( std::pair<std::string, HandleData> const & hd )
return hd.second.objTypeEnum == objectTypeValue.vulkanValue; { return hd.second.objTypeEnum == objectTypeValue.vulkanValue; } ) != m_handles.end(),
} ) != m_handles.end(),
objectTypeValue.xmlLine, objectTypeValue.xmlLine,
"VkObjectType value <" + objectTypeValue.vulkanValue + "VkObjectType value <" + objectTypeValue.vulkanValue +
"> not specified as \"objtypeenum\" for any handle" ); "> not specified as \"objtypeenum\" for any handle" );
@ -10966,8 +10943,8 @@ void VulkanHppGenerator::checkCorrectness()
std::string const & selection = data.selection; std::string const & selection = data.selection;
check( std::find_if( enumIt->second.values.begin(), check( std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(), enumIt->second.values.end(),
[&selection]( EnumValueData const & evd ) { return evd.vulkanValue == selection; } ) != [&selection]( EnumValueData const & evd )
enumIt->second.values.end(), { return evd.vulkanValue == selection; } ) != enumIt->second.values.end(),
data.xmlLine, data.xmlLine,
"union member <" + data.name + "> uses selection <" + selection + "union member <" + data.name + "> uses selection <" + selection +
"> that is not part of the selector type <" + selectorIt->type.type + ">" ); "> that is not part of the selector type <" + selectorIt->type.type + ">" );
@ -10991,8 +10968,8 @@ void VulkanHppGenerator::checkCorrectness()
{ {
check( std::find_if( enumIt->second.values.begin(), check( std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(), enumIt->second.values.end(),
[&enumValue]( auto const & evd ) { return enumValue == evd.vulkanValue; } ) != [&enumValue]( auto const & evd )
enumIt->second.values.end(), { return enumValue == evd.vulkanValue; } ) != enumIt->second.values.end(),
member.xmlLine, member.xmlLine,
"value <" + enumValue + "> for member <" + member.name + "> in structure <" + structure.first + "value <" + enumValue + "> for member <" + member.name + "> in structure <" + structure.first +
" of enum type <" + member.type.type + "> not listed" ); " of enum type <" + member.type.type + "> not listed" );
@ -11126,8 +11103,13 @@ std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
for ( auto commandIt = m_commands.begin(); commandIt != m_commands.end(); ) for ( auto commandIt = m_commands.begin(); commandIt != m_commands.end(); )
{ {
commandIt = commandIt =
std::find_if( commandIt, m_commands.end(), [&handleType]( std::pair<std::string, CommandData> const & cd ) { std::find_if( commandIt,
return std::find_if( cd.second.params.begin(), cd.second.params.end(), [&handleType]( ParamData const & pd ) { m_commands.end(),
[&handleType]( std::pair<std::string, CommandData> const & cd )
{
return std::find_if( cd.second.params.begin(),
cd.second.params.end(),
[&handleType]( ParamData const & pd ) {
return ( pd.type.type == handleType ) && pd.type.isNonConstPointer(); return ( pd.type.type == handleType ) && pd.type.isNonConstPointer();
} ) != cd.second.params.end(); } ) != cd.second.params.end();
} ); } );
@ -11143,9 +11125,9 @@ std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
assert( paramIt != destructorIt->second.params.end() ); assert( paramIt != destructorIt->second.params.end() );
for ( auto pit = destructorIt->second.params.begin(); valid && pit != destructorIt->second.params.end(); ++pit ) for ( auto pit = destructorIt->second.params.begin(); valid && pit != destructorIt->second.params.end(); ++pit )
{ {
valid = ( pit->name == paramIt->len ) || valid = ( pit->name == paramIt->len ) || ( std::find_if( commandIt->second.params.begin(),
( std::find_if( commandIt->second.params.end(),
commandIt->second.params.begin(), commandIt->second.params.end(), [&pit]( ParamData const & pd ) { [&pit]( ParamData const & pd ) {
return pd.type.type == pit->type.type; return pd.type.type == pit->type.type;
} ) != commandIt->second.params.end() ); } ) != commandIt->second.params.end() );
for ( auto cit = commandIt->second.params.begin(); !valid && cit != commandIt->second.params.end(); ++cit ) for ( auto cit = commandIt->second.params.begin(); !valid && cit != commandIt->second.params.end(); ++cit )
@ -11155,8 +11137,8 @@ std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
{ {
valid = std::find_if( structureIt->second.members.begin(), valid = std::find_if( structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&pit]( MemberData const & md ) { return md.type.type == pit->type.type; } ) != [&pit]( MemberData const & md )
structureIt->second.members.end(); { return md.type.type == pit->type.type; } ) != structureIt->second.members.end();
} }
} }
} }
@ -11232,10 +11214,10 @@ size_t VulkanHppGenerator::determineReturnParamIndex( CommandData const &
{ {
// it's a non-const pointer // it's a non-const pointer
// assert that it's not a vector-size parameter // assert that it's not a vector-size parameter
assert( std::find_if( assert( std::find_if( vectorParamIndices.begin(),
vectorParamIndices.begin(), vectorParamIndices.end(), [index]( std::pair<size_t, size_t> const & vpi ) { vectorParamIndices.end(),
return vpi.second == index; [index]( std::pair<size_t, size_t> const & vpi )
} ) == vectorParamIndices.end() ); { return vpi.second == index; } ) == vectorParamIndices.end() );
std::map<size_t, size_t>::const_iterator vpit = vectorParamIndices.find( index ); std::map<size_t, size_t>::const_iterator vpit = vectorParamIndices.find( index );
if ( ( vpit == vectorParamIndices.end() ) || twoStep || ( vectorParamIndices.size() > 1 ) || if ( ( vpit == vectorParamIndices.end() ) || twoStep || ( vectorParamIndices.size() > 1 ) ||
@ -11350,9 +11332,10 @@ std::map<size_t, size_t>
{ {
if ( !it->len.empty() ) if ( !it->len.empty() )
{ {
auto findIt = std::find_if( params.begin(), it, [this, &it]( ParamData const & pd ) { auto findIt = std::find_if( params.begin(),
return ( pd.name == it->len ) || isLenByStructMember( it->len, pd ); it,
} ); [this, &it]( ParamData const & pd )
{ return ( pd.name == it->len ) || isLenByStructMember( it->len, pd ); } );
if ( findIt < it ) if ( findIt < it )
{ {
@ -11646,6 +11629,32 @@ std::string
return sizeCheck; return sizeCheck;
} }
std::string VulkanHppGenerator::getEnumPrefix( int line, std::string const & name, bool bitmask ) const
{
std::string prefix;
if ( name == "VkResult" )
{
prefix = "VK_";
}
else if ( bitmask )
{
// for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
// end that with "Bit"
size_t pos = name.find( "FlagBits" );
check( pos != std::string::npos, line, "bitmask <" + name + "> does not contain <FlagBits>" );
std::string shortenedName = name;
shortenedName.erase( pos, strlen( "FlagBits" ) );
std::string tag = findTag( m_tags, shortenedName );
prefix = toUpperCase( stripPostfix( shortenedName, tag ) ) + "_";
}
else
{
// for a non-bitmask enum, convert the name to upper case
prefix = toUpperCase( name ) + "_";
}
return prefix;
}
std::set<std::string> VulkanHppGenerator::getPlatforms( std::set<std::string> const & extensions ) const std::set<std::string> VulkanHppGenerator::getPlatforms( std::set<std::string> const & extensions ) const
{ {
std::set<std::string> platforms; std::set<std::string> platforms;
@ -11666,9 +11675,10 @@ std::pair<std::string, std::string> VulkanHppGenerator::getPoolTypeAndName( std:
structIt->second.members.end(), structIt->second.members.end(),
[]( MemberData const & md ) { return md.name.find( "Pool" ) != std::string::npos; } ); []( MemberData const & md ) { return md.name.find( "Pool" ) != std::string::npos; } );
assert( memberIt != structIt->second.members.end() ); assert( memberIt != structIt->second.members.end() );
assert( std::find_if( std::next( memberIt ), structIt->second.members.end(), []( MemberData const & md ) { assert( std::find_if( std::next( memberIt ),
return md.name.find( "Pool" ) != std::string::npos; structIt->second.members.end(),
} ) == structIt->second.members.end() ); []( MemberData const & md )
{ return md.name.find( "Pool" ) != std::string::npos; } ) == structIt->second.members.end() );
return std::make_pair( memberIt->type.type, memberIt->name ); return std::make_pair( memberIt->type.type, memberIt->name );
} }
@ -11726,9 +11736,9 @@ bool VulkanHppGenerator::isHandleType( std::string const & type ) const
auto it = m_handles.find( type ); auto it = m_handles.find( type );
if ( it == m_handles.end() ) if ( it == m_handles.end() )
{ {
it = std::find_if( m_handles.begin(), m_handles.end(), [&type]( std::pair<std::string, HandleData> const & hd ) { it = std::find_if( m_handles.begin(),
return hd.second.alias == type; m_handles.end(),
} ); [&type]( std::pair<std::string, HandleData> const & hd ) { return hd.second.alias == type; } );
} }
return ( it != m_handles.end() ); return ( it != m_handles.end() );
} }
@ -11755,8 +11765,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, std::vec
assert( structureIt != m_structures.end() ); assert( structureIt != m_structures.end() );
assert( std::find_if( structureIt->second.members.begin(), assert( std::find_if( structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&n = nameParts[1]]( MemberData const & md ) { return md.name == n; } ) != [&n = nameParts[1]]( MemberData const & md )
structureIt->second.members.end() ); { return md.name == n; } ) != structureIt->second.members.end() );
#endif #endif
return true; return true;
} }
@ -11780,8 +11790,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, ParamDat
assert( structureIt != m_structures.end() ); assert( structureIt != m_structures.end() );
assert( std::find_if( structureIt->second.members.begin(), assert( std::find_if( structureIt->second.members.begin(),
structureIt->second.members.end(), structureIt->second.members.end(),
[&n = nameParts[1]]( MemberData const & md ) { return md.name == n; } ) != [&n = nameParts[1]]( MemberData const & md )
structureIt->second.members.end() ); { return md.name == n; } ) != structureIt->second.members.end() );
#endif #endif
return true; return true;
} }
@ -11823,10 +11833,10 @@ bool VulkanHppGenerator::isStructureChainAnchor( std::string const & type ) cons
auto it = m_structures.find( type ); auto it = m_structures.find( type );
if ( it == m_structures.end() ) if ( it == m_structures.end() )
{ {
it = std::find_if( it = std::find_if( m_structures.begin(),
m_structures.begin(), m_structures.end(), [&type]( std::pair<std::string, StructureData> const & sd ) { m_structures.end(),
return sd.second.aliases.find( type ) != sd.second.aliases.end(); [&type]( std::pair<std::string, StructureData> const & sd )
} ); { return sd.second.aliases.find( type ) != sd.second.aliases.end(); } );
} }
if ( it != m_structures.end() ) if ( it != m_structures.end() )
{ {
@ -11855,8 +11865,8 @@ std::pair<bool, std::map<size_t, std::vector<size_t>>>
} }
return std::make_pair( std::find_if( countToVectorMap.begin(), return std::make_pair( std::find_if( countToVectorMap.begin(),
countToVectorMap.end(), countToVectorMap.end(),
[]( auto const & cvm ) { return 1 < cvm.second.size(); } ) != []( auto const & cvm )
countToVectorMap.end(), { return 1 < cvm.second.size(); } ) != countToVectorMap.end(),
countToVectorMap ); countToVectorMap );
} }
@ -12444,9 +12454,9 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
bool bitmask = ( type == "bitmask" ); bool bitmask = ( type == "bitmask" );
if ( bitmask ) if ( bitmask )
{ {
auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&name]( auto const & bitmask ) { auto bitmaskIt = std::find_if( m_bitmasks.begin(),
return bitmask.second.requirements == name; m_bitmasks.end(),
} ); [&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } );
check( bitmaskIt != m_bitmasks.end(), check( bitmaskIt != m_bitmasks.end(),
line, line,
"enum <" + name + "> is not listed as an requires or bitvalues for any bitmask in the types section" ); "enum <" + name + "> is not listed as an requires or bitvalues for any bitmask in the types section" );
@ -12546,9 +12556,8 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
std::string const & requiresCore = attribute.second; std::string const & requiresCore = attribute.second;
check( std::find_if( m_features.begin(), check( std::find_if( m_features.begin(),
m_features.end(), m_features.end(),
[&requiresCore]( std::pair<std::string, std::string> const & nameNumber ) { [&requiresCore]( std::pair<std::string, std::string> const & nameNumber )
return nameNumber.second == requiresCore; { return nameNumber.second == requiresCore; } ) != m_features.end(),
} ) != m_features.end(),
line, line,
"unknown feature number <" + attribute.second + ">" ); "unknown feature number <" + attribute.second + ">" );
} }
@ -12658,7 +12667,8 @@ void VulkanHppGenerator::readExtensionDisabledType( tinyxml2::XMLElement const *
check( bitmasksIt != m_bitmasks.end(), line, "trying to remove unknown bitmask <" + name + ">" ); check( bitmasksIt != m_bitmasks.end(), line, "trying to remove unknown bitmask <" + name + ">" );
check( bitmasksIt->second.alias.empty(), check( bitmasksIt->second.alias.empty(),
line, line,
"trying to remove disabled bitmask <" + name + "> which has alias <" + bitmasksIt->second.alias + ">" ); "trying to remove disabled bitmask <" + name + "> which has alias <" + bitmasksIt->second.alias +
">" );
m_bitmasks.erase( bitmasksIt ); m_bitmasks.erase( bitmasksIt );
} }
break; break;
@ -13078,9 +13088,8 @@ void VulkanHppGenerator::readPlatform( tinyxml2::XMLElement const * element )
check( std::find_if( m_platforms.begin(), check( std::find_if( m_platforms.begin(),
m_platforms.end(), m_platforms.end(),
[&protect]( std::pair<std::string, PlatformData> const & p ) { [&protect]( std::pair<std::string, PlatformData> const & p )
return p.second.protect == protect; { return p.second.protect == protect; } ) == m_platforms.end(),
} ) == m_platforms.end(),
line, line,
"platform protect <" + protect + "> already specified" ); "platform protect <" + protect + "> already specified" );
check( m_platforms.insert( std::make_pair( name, PlatformData( protect ) ) ).second, check( m_platforms.insert( std::make_pair( name, PlatformData( protect ) ) ).second,
@ -13679,8 +13688,8 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const *
// check if multiple structure members use the very same (not empty) len attribute // check if multiple structure members use the very same (not empty) len attribute
// Note: even though the arrays are not mared as optional, they still might be mutually exclusive (like in // Note: even though the arrays are not mared as optional, they still might be mutually exclusive (like in
// VkWriteDescriptorSet)! That is, there's not enough information available in vk.xml to decide on that, so we need // VkWriteDescriptorSet)! That is, there's not enough information available in vk.xml to decide on that, so we
// this external knowledge! // need this external knowledge!
static std::set<std::string> mutualExclusiveStructs = { "VkAccelerationStructureBuildGeometryInfoKHR", static std::set<std::string> mutualExclusiveStructs = { "VkAccelerationStructureBuildGeometryInfoKHR",
"VkWriteDescriptorSet" }; "VkWriteDescriptorSet" };
static std::set<std::string> multipleLenStructs = { "VkImageConstraintsInfoFUCHSIA", static std::set<std::string> multipleLenStructs = { "VkImageConstraintsInfoFUCHSIA",

4
VulkanHppGenerator.hpp
View File

@ -971,7 +971,9 @@ private:
std::string const & structName, std::string const & structName,
std::string const & prefix, std::string const & prefix,
bool mutualExclusiveLens ) const; bool mutualExclusiveLens ) const;
std::set<std::string> getPlatforms( std::set<std::string> const & extensions ) const; std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) const;
std::set<std::string> getPlatforms(
std::set<std::string> const & extensions ) const;
std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const; std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
std::string getVectorSize( std::vector<ParamData> const & params, std::string getVectorSize( std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,

646
vulkan/vulkan.hpp
View File

@ -67,7 +67,7 @@
#endif #endif
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
# include <dlfcn.h> # include <dlfcn.h>
# elif defined( _WIN32 ) # elif defined( _WIN32 )
typedef struct HINSTANCE__ * HINSTANCE; typedef struct HINSTANCE__ * HINSTANCE;
@ -5444,79 +5444,79 @@ namespace VULKAN_HPP_NAMESPACE
enum class AccessFlagBits2KHR : VkAccessFlags2KHR enum class AccessFlagBits2KHR : VkAccessFlags2KHR
{ {
e2None = VK_ACCESS_2_NONE_KHR, eNone = VK_ACCESS_2_NONE_KHR,
e2IndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR,
e2IndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR, eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR,
e2VertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR,
e2UniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR, eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR,
e2InputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR,
e2ShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR, eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR,
e2ShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR, eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR,
e2ColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR,
e2ColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR,
e2DepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR,
e2DepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR,
e2TransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR, eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR,
e2TransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR,
e2HostRead = VK_ACCESS_2_HOST_READ_BIT_KHR, eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR,
e2HostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR, eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR,
e2MemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR, eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR,
e2MemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR, eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR,
e2ShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR,
e2ShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR,
e2ShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR,
e2TransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
e2TransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, eTransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
e2TransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, eTransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
e2ConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT,
e2CommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV,
e2CommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV,
e2FragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, eFragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
e2AccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR,
e2AccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, eAccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
e2FragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
e2ColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, eColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
e2AccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV,
e2AccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, eAccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
e2ShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
}; };
VULKAN_HPP_INLINE std::string to_string( AccessFlagBits2KHR value ) VULKAN_HPP_INLINE std::string to_string( AccessFlagBits2KHR value )
{ {
switch ( value ) switch ( value )
{ {
case AccessFlagBits2KHR::e2None: return "2None"; case AccessFlagBits2KHR::eNone: return "None";
case AccessFlagBits2KHR::e2IndirectCommandRead: return "2IndirectCommandRead"; case AccessFlagBits2KHR::eIndirectCommandRead: return "IndirectCommandRead";
case AccessFlagBits2KHR::e2IndexRead: return "2IndexRead"; case AccessFlagBits2KHR::eIndexRead: return "IndexRead";
case AccessFlagBits2KHR::e2VertexAttributeRead: return "2VertexAttributeRead"; case AccessFlagBits2KHR::eVertexAttributeRead: return "VertexAttributeRead";
case AccessFlagBits2KHR::e2UniformRead: return "2UniformRead"; case AccessFlagBits2KHR::eUniformRead: return "UniformRead";
case AccessFlagBits2KHR::e2InputAttachmentRead: return "2InputAttachmentRead"; case AccessFlagBits2KHR::eInputAttachmentRead: return "InputAttachmentRead";
case AccessFlagBits2KHR::e2ShaderRead: return "2ShaderRead"; case AccessFlagBits2KHR::eShaderRead: return "ShaderRead";
case AccessFlagBits2KHR::e2ShaderWrite: return "2ShaderWrite"; case AccessFlagBits2KHR::eShaderWrite: return "ShaderWrite";
case AccessFlagBits2KHR::e2ColorAttachmentRead: return "2ColorAttachmentRead"; case AccessFlagBits2KHR::eColorAttachmentRead: return "ColorAttachmentRead";
case AccessFlagBits2KHR::e2ColorAttachmentWrite: return "2ColorAttachmentWrite"; case AccessFlagBits2KHR::eColorAttachmentWrite: return "ColorAttachmentWrite";
case AccessFlagBits2KHR::e2DepthStencilAttachmentRead: return "2DepthStencilAttachmentRead"; case AccessFlagBits2KHR::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
case AccessFlagBits2KHR::e2DepthStencilAttachmentWrite: return "2DepthStencilAttachmentWrite"; case AccessFlagBits2KHR::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
case AccessFlagBits2KHR::e2TransferRead: return "2TransferRead"; case AccessFlagBits2KHR::eTransferRead: return "TransferRead";
case AccessFlagBits2KHR::e2TransferWrite: return "2TransferWrite"; case AccessFlagBits2KHR::eTransferWrite: return "TransferWrite";
case AccessFlagBits2KHR::e2HostRead: return "2HostRead"; case AccessFlagBits2KHR::eHostRead: return "HostRead";
case AccessFlagBits2KHR::e2HostWrite: return "2HostWrite"; case AccessFlagBits2KHR::eHostWrite: return "HostWrite";
case AccessFlagBits2KHR::e2MemoryRead: return "2MemoryRead"; case AccessFlagBits2KHR::eMemoryRead: return "MemoryRead";
case AccessFlagBits2KHR::e2MemoryWrite: return "2MemoryWrite"; case AccessFlagBits2KHR::eMemoryWrite: return "MemoryWrite";
case AccessFlagBits2KHR::e2ShaderSampledRead: return "2ShaderSampledRead"; case AccessFlagBits2KHR::eShaderSampledRead: return "ShaderSampledRead";
case AccessFlagBits2KHR::e2ShaderStorageRead: return "2ShaderStorageRead"; case AccessFlagBits2KHR::eShaderStorageRead: return "ShaderStorageRead";
case AccessFlagBits2KHR::e2ShaderStorageWrite: return "2ShaderStorageWrite"; case AccessFlagBits2KHR::eShaderStorageWrite: return "ShaderStorageWrite";
case AccessFlagBits2KHR::e2TransformFeedbackWriteExt: return "2TransformFeedbackWriteExt"; case AccessFlagBits2KHR::eTransformFeedbackWriteExt: return "TransformFeedbackWriteExt";
case AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt: return "2TransformFeedbackCounterReadExt"; case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt: return "TransformFeedbackCounterReadExt";
case AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt: return "2TransformFeedbackCounterWriteExt"; case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt: return "TransformFeedbackCounterWriteExt";
case AccessFlagBits2KHR::e2ConditionalRenderingReadExt: return "2ConditionalRenderingReadExt"; case AccessFlagBits2KHR::eConditionalRenderingReadExt: return "ConditionalRenderingReadExt";
case AccessFlagBits2KHR::e2CommandPreprocessReadNv: return "2CommandPreprocessReadNv"; case AccessFlagBits2KHR::eCommandPreprocessReadNv: return "CommandPreprocessReadNv";
case AccessFlagBits2KHR::e2CommandPreprocessWriteNv: return "2CommandPreprocessWriteNv"; case AccessFlagBits2KHR::eCommandPreprocessWriteNv: return "CommandPreprocessWriteNv";
case AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead: return "2FragmentShadingRateAttachmentRead"; case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead: return "FragmentShadingRateAttachmentRead";
case AccessFlagBits2KHR::e2AccelerationStructureRead: return "2AccelerationStructureRead"; case AccessFlagBits2KHR::eAccelerationStructureRead: return "AccelerationStructureRead";
case AccessFlagBits2KHR::e2AccelerationStructureWrite: return "2AccelerationStructureWrite"; case AccessFlagBits2KHR::eAccelerationStructureWrite: return "AccelerationStructureWrite";
case AccessFlagBits2KHR::e2FragmentDensityMapReadExt: return "2FragmentDensityMapReadExt"; case AccessFlagBits2KHR::eFragmentDensityMapReadExt: return "FragmentDensityMapReadExt";
case AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt: return "2ColorAttachmentReadNoncoherentExt"; case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt: return "ColorAttachmentReadNoncoherentExt";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -8975,84 +8975,84 @@ namespace VULKAN_HPP_NAMESPACE
enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR
{ {
e2None = VK_PIPELINE_STAGE_2_NONE_KHR, eNone = VK_PIPELINE_STAGE_2_NONE_KHR,
e2TopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
e2DrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR,
e2VertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR,
e2VertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR, eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR,
e2TessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR, eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR,
e2TessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR, eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR,
e2GeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR, eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR,
e2FragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR,
e2EarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR,
e2LateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR,
e2ColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR,
e2ComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR, eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR,
e2AllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR,
e2BottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR,
e2Host = VK_PIPELINE_STAGE_2_HOST_BIT_KHR, eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR,
e2AllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR,
e2AllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR,
e2Copy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR, eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR,
e2Resolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR,
e2Blit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR,
e2Clear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR,
e2IndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR,
e2VertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR,
e2PreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR, ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR,
e2TransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,
e2ConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
e2CommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV,
e2FragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, eFragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
e2AccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, eAccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
e2RayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR,
e2FragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, eFragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
e2TaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
e2MeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
e2AccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, eAccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
e2RayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
e2ShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
e2Transfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
}; };
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits2KHR value ) VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits2KHR value )
{ {
switch ( value ) switch ( value )
{ {
case PipelineStageFlagBits2KHR::e2None: return "2None"; case PipelineStageFlagBits2KHR::eNone: return "None";
case PipelineStageFlagBits2KHR::e2TopOfPipe: return "2TopOfPipe"; case PipelineStageFlagBits2KHR::eTopOfPipe: return "TopOfPipe";
case PipelineStageFlagBits2KHR::e2DrawIndirect: return "2DrawIndirect"; case PipelineStageFlagBits2KHR::eDrawIndirect: return "DrawIndirect";
case PipelineStageFlagBits2KHR::e2VertexInput: return "2VertexInput"; case PipelineStageFlagBits2KHR::eVertexInput: return "VertexInput";
case PipelineStageFlagBits2KHR::e2VertexShader: return "2VertexShader"; case PipelineStageFlagBits2KHR::eVertexShader: return "VertexShader";
case PipelineStageFlagBits2KHR::e2TessellationControlShader: return "2TessellationControlShader"; case PipelineStageFlagBits2KHR::eTessellationControlShader: return "TessellationControlShader";
case PipelineStageFlagBits2KHR::e2TessellationEvaluationShader: return "2TessellationEvaluationShader"; case PipelineStageFlagBits2KHR::eTessellationEvaluationShader: return "TessellationEvaluationShader";
case PipelineStageFlagBits2KHR::e2GeometryShader: return "2GeometryShader"; case PipelineStageFlagBits2KHR::eGeometryShader: return "GeometryShader";
case PipelineStageFlagBits2KHR::e2FragmentShader: return "2FragmentShader"; case PipelineStageFlagBits2KHR::eFragmentShader: return "FragmentShader";
case PipelineStageFlagBits2KHR::e2EarlyFragmentTests: return "2EarlyFragmentTests"; case PipelineStageFlagBits2KHR::eEarlyFragmentTests: return "EarlyFragmentTests";
case PipelineStageFlagBits2KHR::e2LateFragmentTests: return "2LateFragmentTests"; case PipelineStageFlagBits2KHR::eLateFragmentTests: return "LateFragmentTests";
case PipelineStageFlagBits2KHR::e2ColorAttachmentOutput: return "2ColorAttachmentOutput"; case PipelineStageFlagBits2KHR::eColorAttachmentOutput: return "ColorAttachmentOutput";
case PipelineStageFlagBits2KHR::e2ComputeShader: return "2ComputeShader"; case PipelineStageFlagBits2KHR::eComputeShader: return "ComputeShader";
case PipelineStageFlagBits2KHR::e2AllTransfer: return "2AllTransfer"; case PipelineStageFlagBits2KHR::eAllTransfer: return "AllTransfer";
case PipelineStageFlagBits2KHR::e2BottomOfPipe: return "2BottomOfPipe"; case PipelineStageFlagBits2KHR::eBottomOfPipe: return "BottomOfPipe";
case PipelineStageFlagBits2KHR::e2Host: return "2Host"; case PipelineStageFlagBits2KHR::eHost: return "Host";
case PipelineStageFlagBits2KHR::e2AllGraphics: return "2AllGraphics"; case PipelineStageFlagBits2KHR::eAllGraphics: return "AllGraphics";
case PipelineStageFlagBits2KHR::e2AllCommands: return "2AllCommands"; case PipelineStageFlagBits2KHR::eAllCommands: return "AllCommands";
case PipelineStageFlagBits2KHR::e2Copy: return "2Copy"; case PipelineStageFlagBits2KHR::eCopy: return "Copy";
case PipelineStageFlagBits2KHR::e2Resolve: return "2Resolve"; case PipelineStageFlagBits2KHR::eResolve: return "Resolve";
case PipelineStageFlagBits2KHR::e2Blit: return "2Blit"; case PipelineStageFlagBits2KHR::eBlit: return "Blit";
case PipelineStageFlagBits2KHR::e2Clear: return "2Clear"; case PipelineStageFlagBits2KHR::eClear: return "Clear";
case PipelineStageFlagBits2KHR::e2IndexInput: return "2IndexInput"; case PipelineStageFlagBits2KHR::eIndexInput: return "IndexInput";
case PipelineStageFlagBits2KHR::e2VertexAttributeInput: return "2VertexAttributeInput"; case PipelineStageFlagBits2KHR::eVertexAttributeInput: return "VertexAttributeInput";
case PipelineStageFlagBits2KHR::e2PreRasterizationShaders: return "2PreRasterizationShaders"; case PipelineStageFlagBits2KHR::ePreRasterizationShaders: return "PreRasterizationShaders";
case PipelineStageFlagBits2KHR::e2TransformFeedbackExt: return "2TransformFeedbackExt"; case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt";
case PipelineStageFlagBits2KHR::e2ConditionalRenderingExt: return "2ConditionalRenderingExt"; case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt";
case PipelineStageFlagBits2KHR::e2CommandPreprocessNv: return "2CommandPreprocessNv"; case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv";
case PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment: return "2FragmentShadingRateAttachment"; case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment";
case PipelineStageFlagBits2KHR::e2AccelerationStructureBuild: return "2AccelerationStructureBuild"; case PipelineStageFlagBits2KHR::eAccelerationStructureBuild: return "AccelerationStructureBuild";
case PipelineStageFlagBits2KHR::e2RayTracingShader: return "2RayTracingShader"; case PipelineStageFlagBits2KHR::eRayTracingShader: return "RayTracingShader";
case PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt: return "2FragmentDensityProcessExt"; case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt: return "FragmentDensityProcessExt";
case PipelineStageFlagBits2KHR::e2TaskShaderNv: return "2TaskShaderNv"; case PipelineStageFlagBits2KHR::eTaskShaderNv: return "TaskShaderNv";
case PipelineStageFlagBits2KHR::e2MeshShaderNv: return "2MeshShaderNv"; case PipelineStageFlagBits2KHR::eMeshShaderNv: return "MeshShaderNv";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -11868,30 +11868,28 @@ namespace VULKAN_HPP_NAMESPACE
enum : VkFlags64 enum : VkFlags64
{ {
allFlags = allFlags =
VkFlags64( AccessFlagBits2KHR::e2None ) | VkFlags64( AccessFlagBits2KHR::e2IndirectCommandRead ) | VkFlags64( AccessFlagBits2KHR::eNone ) | VkFlags64( AccessFlagBits2KHR::eIndirectCommandRead ) |
VkFlags64( AccessFlagBits2KHR::e2IndexRead ) | VkFlags64( AccessFlagBits2KHR::e2VertexAttributeRead ) | VkFlags64( AccessFlagBits2KHR::eIndexRead ) | VkFlags64( AccessFlagBits2KHR::eVertexAttributeRead ) |
VkFlags64( AccessFlagBits2KHR::e2UniformRead ) | VkFlags64( AccessFlagBits2KHR::e2InputAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eUniformRead ) | VkFlags64( AccessFlagBits2KHR::eInputAttachmentRead ) |
VkFlags64( AccessFlagBits2KHR::e2ShaderRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderRead ) | VkFlags64( AccessFlagBits2KHR::eShaderWrite ) |
VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentWrite ) |
VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentRead ) |
VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eTransferRead ) |
VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eTransferWrite ) | VkFlags64( AccessFlagBits2KHR::eHostRead ) |
VkFlags64( AccessFlagBits2KHR::e2TransferRead ) | VkFlags64( AccessFlagBits2KHR::e2TransferWrite ) | VkFlags64( AccessFlagBits2KHR::eHostWrite ) | VkFlags64( AccessFlagBits2KHR::eMemoryRead ) |
VkFlags64( AccessFlagBits2KHR::e2HostRead ) | VkFlags64( AccessFlagBits2KHR::e2HostWrite ) | VkFlags64( AccessFlagBits2KHR::eMemoryWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderSampledRead ) |
VkFlags64( AccessFlagBits2KHR::e2MemoryRead ) | VkFlags64( AccessFlagBits2KHR::e2MemoryWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderStorageRead ) | VkFlags64( AccessFlagBits2KHR::eShaderStorageWrite ) |
VkFlags64( AccessFlagBits2KHR::e2ShaderSampledRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderStorageRead ) | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) |
VkFlags64( AccessFlagBits2KHR::e2ShaderStorageWrite ) | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) |
VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) |
VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) | VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) |
VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) | VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) |
VkFlags64( AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) | VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) |
VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessReadNv ) | VkFlags64( AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) |
VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) | VkFlags64( AccessFlagBits2KHR::eAccelerationStructureRead ) |
VkFlags64( AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eAccelerationStructureWrite ) |
VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureRead ) | VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadExt ) |
VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureWrite ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
VkFlags64( AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) |
VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt )
}; };
}; };
@ -11924,68 +11922,68 @@ namespace VULKAN_HPP_NAMESPACE
return "{}"; return "{}";
std::string result; std::string result;
if ( value & AccessFlagBits2KHR::e2IndirectCommandRead ) if ( value & AccessFlagBits2KHR::eIndirectCommandRead )
result += "2IndirectCommandRead | "; result += "IndirectCommandRead | ";
if ( value & AccessFlagBits2KHR::e2IndexRead ) if ( value & AccessFlagBits2KHR::eIndexRead )
result += "2IndexRead | "; result += "IndexRead | ";
if ( value & AccessFlagBits2KHR::e2VertexAttributeRead ) if ( value & AccessFlagBits2KHR::eVertexAttributeRead )
result += "2VertexAttributeRead | "; result += "VertexAttributeRead | ";
if ( value & AccessFlagBits2KHR::e2UniformRead ) if ( value & AccessFlagBits2KHR::eUniformRead )
result += "2UniformRead | "; result += "UniformRead | ";
if ( value & AccessFlagBits2KHR::e2InputAttachmentRead ) if ( value & AccessFlagBits2KHR::eInputAttachmentRead )
result += "2InputAttachmentRead | "; result += "InputAttachmentRead | ";
if ( value & AccessFlagBits2KHR::e2ShaderRead ) if ( value & AccessFlagBits2KHR::eShaderRead )
result += "2ShaderRead | "; result += "ShaderRead | ";
if ( value & AccessFlagBits2KHR::e2ShaderWrite ) if ( value & AccessFlagBits2KHR::eShaderWrite )
result += "2ShaderWrite | "; result += "ShaderWrite | ";
if ( value & AccessFlagBits2KHR::e2ColorAttachmentRead ) if ( value & AccessFlagBits2KHR::eColorAttachmentRead )
result += "2ColorAttachmentRead | "; result += "ColorAttachmentRead | ";
if ( value & AccessFlagBits2KHR::e2ColorAttachmentWrite ) if ( value & AccessFlagBits2KHR::eColorAttachmentWrite )
result += "2ColorAttachmentWrite | "; result += "ColorAttachmentWrite | ";
if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentRead )
result += "2DepthStencilAttachmentRead | "; result += "DepthStencilAttachmentRead | ";
if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite )
result += "2DepthStencilAttachmentWrite | "; result += "DepthStencilAttachmentWrite | ";
if ( value & AccessFlagBits2KHR::e2TransferRead ) if ( value & AccessFlagBits2KHR::eTransferRead )
result += "2TransferRead | "; result += "TransferRead | ";
if ( value & AccessFlagBits2KHR::e2TransferWrite ) if ( value & AccessFlagBits2KHR::eTransferWrite )
result += "2TransferWrite | "; result += "TransferWrite | ";
if ( value & AccessFlagBits2KHR::e2HostRead ) if ( value & AccessFlagBits2KHR::eHostRead )
result += "2HostRead | "; result += "HostRead | ";
if ( value & AccessFlagBits2KHR::e2HostWrite ) if ( value & AccessFlagBits2KHR::eHostWrite )
result += "2HostWrite | "; result += "HostWrite | ";
if ( value & AccessFlagBits2KHR::e2MemoryRead ) if ( value & AccessFlagBits2KHR::eMemoryRead )
result += "2MemoryRead | "; result += "MemoryRead | ";
if ( value & AccessFlagBits2KHR::e2MemoryWrite ) if ( value & AccessFlagBits2KHR::eMemoryWrite )
result += "2MemoryWrite | "; result += "MemoryWrite | ";
if ( value & AccessFlagBits2KHR::e2ShaderSampledRead ) if ( value & AccessFlagBits2KHR::eShaderSampledRead )
result += "2ShaderSampledRead | "; result += "ShaderSampledRead | ";
if ( value & AccessFlagBits2KHR::e2ShaderStorageRead ) if ( value & AccessFlagBits2KHR::eShaderStorageRead )
result += "2ShaderStorageRead | "; result += "ShaderStorageRead | ";
if ( value & AccessFlagBits2KHR::e2ShaderStorageWrite ) if ( value & AccessFlagBits2KHR::eShaderStorageWrite )
result += "2ShaderStorageWrite | "; result += "ShaderStorageWrite | ";
if ( value & AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteExt )
result += "2TransformFeedbackWriteExt | "; result += "TransformFeedbackWriteExt | ";
if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt )
result += "2TransformFeedbackCounterReadExt | "; result += "TransformFeedbackCounterReadExt | ";
if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt )
result += "2TransformFeedbackCounterWriteExt | "; result += "TransformFeedbackCounterWriteExt | ";
if ( value & AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) if ( value & AccessFlagBits2KHR::eConditionalRenderingReadExt )
result += "2ConditionalRenderingReadExt | "; result += "ConditionalRenderingReadExt | ";
if ( value & AccessFlagBits2KHR::e2CommandPreprocessReadNv ) if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNv )
result += "2CommandPreprocessReadNv | "; result += "CommandPreprocessReadNv | ";
if ( value & AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNv )
result += "2CommandPreprocessWriteNv | "; result += "CommandPreprocessWriteNv | ";
if ( value & AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) if ( value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead )
result += "2FragmentShadingRateAttachmentRead | "; result += "FragmentShadingRateAttachmentRead | ";
if ( value & AccessFlagBits2KHR::e2AccelerationStructureRead ) if ( value & AccessFlagBits2KHR::eAccelerationStructureRead )
result += "2AccelerationStructureRead | "; result += "AccelerationStructureRead | ";
if ( value & AccessFlagBits2KHR::e2AccelerationStructureWrite ) if ( value & AccessFlagBits2KHR::eAccelerationStructureWrite )
result += "2AccelerationStructureWrite | "; result += "AccelerationStructureWrite | ";
if ( value & AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadExt )
result += "2FragmentDensityMapReadExt | "; result += "FragmentDensityMapReadExt | ";
if ( value & AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt ) if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
result += "2ColorAttachmentReadNoncoherentExt | "; result += "ColorAttachmentReadNoncoherentExt | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -15633,32 +15631,32 @@ namespace VULKAN_HPP_NAMESPACE
enum : VkFlags64 enum : VkFlags64
{ {
allFlags = allFlags =
VkFlags64( PipelineStageFlagBits2KHR::e2None ) | VkFlags64( PipelineStageFlagBits2KHR::e2TopOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eNone ) | VkFlags64( PipelineStageFlagBits2KHR::eTopOfPipe ) |
VkFlags64( PipelineStageFlagBits2KHR::e2DrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::e2VertexInput ) | VkFlags64( PipelineStageFlagBits2KHR::eDrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexInput ) |
VkFlags64( PipelineStageFlagBits2KHR::e2VertexShader ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2TessellationControlShader ) | VkFlags64( PipelineStageFlagBits2KHR::eTessellationControlShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) | VkFlags64( PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2GeometryShader ) | VkFlags64( PipelineStageFlagBits2KHR::eGeometryShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShader ) | VkFlags64( PipelineStageFlagBits2KHR::eFragmentShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) | VkFlags64( PipelineStageFlagBits2KHR::eEarlyFragmentTests ) |
VkFlags64( PipelineStageFlagBits2KHR::e2LateFragmentTests ) | VkFlags64( PipelineStageFlagBits2KHR::eLateFragmentTests ) |
VkFlags64( PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) | VkFlags64( PipelineStageFlagBits2KHR::eColorAttachmentOutput ) |
VkFlags64( PipelineStageFlagBits2KHR::e2ComputeShader ) | VkFlags64( PipelineStageFlagBits2KHR::eComputeShader ) | VkFlags64( PipelineStageFlagBits2KHR::eAllTransfer ) |
VkFlags64( PipelineStageFlagBits2KHR::e2AllTransfer ) | VkFlags64( PipelineStageFlagBits2KHR::e2BottomOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eBottomOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eHost ) |
VkFlags64( PipelineStageFlagBits2KHR::e2Host ) | VkFlags64( PipelineStageFlagBits2KHR::e2AllGraphics ) | VkFlags64( PipelineStageFlagBits2KHR::eAllGraphics ) | VkFlags64( PipelineStageFlagBits2KHR::eAllCommands ) |
VkFlags64( PipelineStageFlagBits2KHR::e2AllCommands ) | VkFlags64( PipelineStageFlagBits2KHR::e2Copy ) | VkFlags64( PipelineStageFlagBits2KHR::eCopy ) | VkFlags64( PipelineStageFlagBits2KHR::eResolve ) |
VkFlags64( PipelineStageFlagBits2KHR::e2Resolve ) | VkFlags64( PipelineStageFlagBits2KHR::e2Blit ) | VkFlags64( PipelineStageFlagBits2KHR::eBlit ) | VkFlags64( PipelineStageFlagBits2KHR::eClear ) |
VkFlags64( PipelineStageFlagBits2KHR::e2Clear ) | VkFlags64( PipelineStageFlagBits2KHR::e2IndexInput ) | VkFlags64( PipelineStageFlagBits2KHR::eIndexInput ) |
VkFlags64( PipelineStageFlagBits2KHR::e2VertexAttributeInput ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexAttributeInput ) |
VkFlags64( PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) | VkFlags64( PipelineStageFlagBits2KHR::ePreRasterizationShaders ) |
VkFlags64( PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) | VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) |
VkFlags64( PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) | VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) |
VkFlags64( PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) | VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) |
VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) | VkFlags64( PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) |
VkFlags64( PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) | VkFlags64( PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) |
VkFlags64( PipelineStageFlagBits2KHR::e2RayTracingShader ) | VkFlags64( PipelineStageFlagBits2KHR::eRayTracingShader ) |
VkFlags64( PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) | VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) |
VkFlags64( PipelineStageFlagBits2KHR::e2TaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::e2MeshShaderNv ) VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNv )
}; };
}; };
@ -15692,72 +15690,72 @@ namespace VULKAN_HPP_NAMESPACE
return "{}"; return "{}";
std::string result; std::string result;
if ( value & PipelineStageFlagBits2KHR::e2TopOfPipe ) if ( value & PipelineStageFlagBits2KHR::eTopOfPipe )
result += "2TopOfPipe | "; result += "TopOfPipe | ";
if ( value & PipelineStageFlagBits2KHR::e2DrawIndirect ) if ( value & PipelineStageFlagBits2KHR::eDrawIndirect )
result += "2DrawIndirect | "; result += "DrawIndirect | ";
if ( value & PipelineStageFlagBits2KHR::e2VertexInput ) if ( value & PipelineStageFlagBits2KHR::eVertexInput )
result += "2VertexInput | "; result += "VertexInput | ";
if ( value & PipelineStageFlagBits2KHR::e2VertexShader ) if ( value & PipelineStageFlagBits2KHR::eVertexShader )
result += "2VertexShader | "; result += "VertexShader | ";
if ( value & PipelineStageFlagBits2KHR::e2TessellationControlShader ) if ( value & PipelineStageFlagBits2KHR::eTessellationControlShader )
result += "2TessellationControlShader | "; result += "TessellationControlShader | ";
if ( value & PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) if ( value & PipelineStageFlagBits2KHR::eTessellationEvaluationShader )
result += "2TessellationEvaluationShader | "; result += "TessellationEvaluationShader | ";
if ( value & PipelineStageFlagBits2KHR::e2GeometryShader ) if ( value & PipelineStageFlagBits2KHR::eGeometryShader )
result += "2GeometryShader | "; result += "GeometryShader | ";
if ( value & PipelineStageFlagBits2KHR::e2FragmentShader ) if ( value & PipelineStageFlagBits2KHR::eFragmentShader )
result += "2FragmentShader | "; result += "FragmentShader | ";
if ( value & PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) if ( value & PipelineStageFlagBits2KHR::eEarlyFragmentTests )
result += "2EarlyFragmentTests | "; result += "EarlyFragmentTests | ";
if ( value & PipelineStageFlagBits2KHR::e2LateFragmentTests ) if ( value & PipelineStageFlagBits2KHR::eLateFragmentTests )
result += "2LateFragmentTests | "; result += "LateFragmentTests | ";
if ( value & PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) if ( value & PipelineStageFlagBits2KHR::eColorAttachmentOutput )
result += "2ColorAttachmentOutput | "; result += "ColorAttachmentOutput | ";
if ( value & PipelineStageFlagBits2KHR::e2ComputeShader ) if ( value & PipelineStageFlagBits2KHR::eComputeShader )
result += "2ComputeShader | "; result += "ComputeShader | ";
if ( value & PipelineStageFlagBits2KHR::e2AllTransfer ) if ( value & PipelineStageFlagBits2KHR::eAllTransfer )
result += "2AllTransfer | "; result += "AllTransfer | ";
if ( value & PipelineStageFlagBits2KHR::e2BottomOfPipe ) if ( value & PipelineStageFlagBits2KHR::eBottomOfPipe )
result += "2BottomOfPipe | "; result += "BottomOfPipe | ";
if ( value & PipelineStageFlagBits2KHR::e2Host ) if ( value & PipelineStageFlagBits2KHR::eHost )
result += "2Host | "; result += "Host | ";
if ( value & PipelineStageFlagBits2KHR::e2AllGraphics ) if ( value & PipelineStageFlagBits2KHR::eAllGraphics )
result += "2AllGraphics | "; result += "AllGraphics | ";
if ( value & PipelineStageFlagBits2KHR::e2AllCommands ) if ( value & PipelineStageFlagBits2KHR::eAllCommands )
result += "2AllCommands | "; result += "AllCommands | ";
if ( value & PipelineStageFlagBits2KHR::e2Copy ) if ( value & PipelineStageFlagBits2KHR::eCopy )
result += "2Copy | "; result += "Copy | ";
if ( value & PipelineStageFlagBits2KHR::e2Resolve ) if ( value & PipelineStageFlagBits2KHR::eResolve )
result += "2Resolve | "; result += "Resolve | ";
if ( value & PipelineStageFlagBits2KHR::e2Blit ) if ( value & PipelineStageFlagBits2KHR::eBlit )
result += "2Blit | "; result += "Blit | ";
if ( value & PipelineStageFlagBits2KHR::e2Clear ) if ( value & PipelineStageFlagBits2KHR::eClear )
result += "2Clear | "; result += "Clear | ";
if ( value & PipelineStageFlagBits2KHR::e2IndexInput ) if ( value & PipelineStageFlagBits2KHR::eIndexInput )
result += "2IndexInput | "; result += "IndexInput | ";
if ( value & PipelineStageFlagBits2KHR::e2VertexAttributeInput ) if ( value & PipelineStageFlagBits2KHR::eVertexAttributeInput )
result += "2VertexAttributeInput | "; result += "VertexAttributeInput | ";
if ( value & PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) if ( value & PipelineStageFlagBits2KHR::ePreRasterizationShaders )
result += "2PreRasterizationShaders | "; result += "PreRasterizationShaders | ";
if ( value & PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt )
result += "2TransformFeedbackExt | "; result += "TransformFeedbackExt | ";
if ( value & PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt )
result += "2ConditionalRenderingExt | "; result += "ConditionalRenderingExt | ";
if ( value & PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv )
result += "2CommandPreprocessNv | "; result += "CommandPreprocessNv | ";
if ( value & PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) if ( value & PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment )
result += "2FragmentShadingRateAttachment | "; result += "FragmentShadingRateAttachment | ";
if ( value & PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) if ( value & PipelineStageFlagBits2KHR::eAccelerationStructureBuild )
result += "2AccelerationStructureBuild | "; result += "AccelerationStructureBuild | ";
if ( value & PipelineStageFlagBits2KHR::e2RayTracingShader ) if ( value & PipelineStageFlagBits2KHR::eRayTracingShader )
result += "2RayTracingShader | "; result += "RayTracingShader | ";
if ( value & PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessExt )
result += "2FragmentDensityProcessExt | "; result += "FragmentDensityProcessExt | ";
if ( value & PipelineStageFlagBits2KHR::e2TaskShaderNv ) if ( value & PipelineStageFlagBits2KHR::eTaskShaderNv )
result += "2TaskShaderNv | "; result += "TaskShaderNv | ";
if ( value & PipelineStageFlagBits2KHR::e2MeshShaderNv ) if ( value & PipelineStageFlagBits2KHR::eMeshShaderNv )
result += "2MeshShaderNv | "; result += "MeshShaderNv | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -17777,7 +17775,7 @@ namespace VULKAN_HPP_NAMESPACE
throwResultException( result, message ); throwResultException( result, message );
} }
#endif #endif
return ResultValue<T>( result, data ); return ResultValue<T>( result, std::move( data ) );
} }
#ifndef VULKAN_HPP_NO_SMART_HANDLE #ifndef VULKAN_HPP_NO_SMART_HANDLE
@ -112145,7 +112143,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( !vulkanLibraryName.empty() ) if ( !vulkanLibraryName.empty() )
{ {
# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL ); m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
# elif defined( _WIN32 ) # elif defined( _WIN32 )
m_library = ::LoadLibraryA( vulkanLibraryName.c_str() ); m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
@ -112155,7 +112153,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
# if defined( __linux__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
if ( m_library == nullptr ) if ( m_library == nullptr )
{ {
@ -112199,7 +112197,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( m_library ) if ( m_library )
{ {
# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
dlclose( m_library ); dlclose( m_library );
# elif defined( _WIN32 ) # elif defined( _WIN32 )
::FreeLibrary( m_library ); ::FreeLibrary( m_library );
@ -112212,7 +112210,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename T> template <typename T>
T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
{ {
# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
return (T)dlsym( m_library, function ); return (T)dlsym( m_library, function );
# elif defined( _WIN32 ) # elif defined( _WIN32 )
return ( T )::GetProcAddress( m_library, function ); return ( T )::GetProcAddress( m_library, function );
@ -112227,7 +112225,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
private: private:
# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) # if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
void * m_library; void * m_library;
# elif defined( _WIN32 ) # elif defined( _WIN32 )
::HINSTANCE m_library; ::HINSTANCE m_library;