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;
// the size-parameters of vector parameters are not explicitly used in the enhanced API
std::for_each(
vectorParamIndices.begin(), vectorParamIndices.end(), [&skippedParams]( std::pair<size_t, size_t> const & vp ) {
std::for_each( vectorParamIndices.begin(),
vectorParamIndices.end(),
[&skippedParams]( std::pair<size_t, size_t> const & vp )
{
if ( vp.second != INVALID_INDEX )
{
skippedParams.insert( vp.second );
@ -475,29 +477,6 @@ std::string getEnumPostfix( std::string const & name, std::set<std::string> cons
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 )
{
// 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 convertedName;
convertedName.reserve( name.size() );
bool lowerOrDigit = false;
bool previousIsLowerCase = false;
bool previousIsDigit = false;
for ( auto c : name )
{
if ( islower( c ) || isdigit( c ) )
{
lowerOrDigit = true;
}
else if ( lowerOrDigit )
if ( ( isupper( c ) && ( previousIsLowerCase || previousIsDigit ) ) || ( isdigit( c ) && !previousIsDigit ) )
{
convertedName.push_back( '_' );
lowerOrDigit = false;
}
convertedName.push_back( static_cast<char>( toupper( c ) ) );
previousIsLowerCase = !!islower( c );
previousIsDigit = !!isdigit( c );
}
return convertedName;
}
@ -873,9 +847,9 @@ void VulkanHppGenerator::appendArguments( std::string & str,
}
else
{
it = find_if( vectorParamIndices.begin(), vectorParamIndices.end(), [i]( std::pair<size_t, size_t> const & vpi ) {
return vpi.second == i;
} );
it = find_if( vectorParamIndices.begin(),
vectorParamIndices.end(),
[i]( std::pair<size_t, size_t> const & vpi ) { return vpi.second == i; } );
if ( it != vectorParamIndices.end() )
{
appendArgumentCount( str, it->first, commandData.params[it->first].name, templateParamIndex );
@ -1380,8 +1354,8 @@ void VulkanHppGenerator::appendCommand( std::string & str,
break;
case 2:
{
// two returns and two vectors! But one input vector, one output vector of the same size, and one output
// value
// two returns and two vectors! But one input vector, one output vector of the same size, and one
// output value
if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) &&
( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ) &&
( 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" );
if ( enumData.second.isBitmask )
{
auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&enumData]( auto const & bitmask ) {
return bitmask.second.requirements == enumData.first;
} );
auto bitmaskIt =
std::find_if( m_bitmasks.begin(),
m_bitmasks.end(),
[&enumData]( auto const & bitmask ) { return bitmask.second.requirements == enumData.first; } );
assert( bitmaskIt != m_bitmasks.end() );
str += " : " + bitmaskIt->first;
}
@ -2524,10 +2499,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
{
assert( encounteredValue );
// make sure to only list alias values that differ from all non-alias values
if ( std::find_if(
enumData.second.values.begin(), enumData.second.values.end(), [&alias]( EnumValueData const & evd ) {
return alias.second.second == evd.vkValue;
} ) == enumData.second.values.end() )
if ( std::find_if( enumData.second.values.begin(),
enumData.second.values.end(),
[&alias]( EnumValueData const & evd )
{ return alias.second.second == evd.vkValue; } ) == enumData.second.values.end() )
{
#if !defined( NDEBUG )
auto enumIt =
@ -3150,10 +3125,10 @@ ${CppTypeFromDebugReportObjectTypeEXT}
assert( !handleData.second.objTypeEnum.empty() );
enumIt = m_enums.find( "VkObjectType" );
assert( enumIt != m_enums.end() );
valueIt = std::find_if(
enumIt->second.values.begin(), enumIt->second.values.end(), [&handleData]( EnumValueData const & evd ) {
return evd.vulkanValue == handleData.second.objTypeEnum;
} );
valueIt = std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&handleData]( EnumValueData const & evd )
{ return evd.vulkanValue == handleData.second.objTypeEnum; } );
assert( valueIt != enumIt->second.values.end() );
str += replaceWithMap( templateString,
@ -3483,9 +3458,9 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
auto enumIt = m_enums.find( "VkObjectType" );
assert( enumIt != m_enums.end() );
auto valueIt =
std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), [&handle]( EnumValueData const & evd ) {
return evd.vulkanValue == handle.second.objTypeEnum;
} );
std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&handle]( EnumValueData const & evd ) { return evd.vulkanValue == handle.second.objTypeEnum; } );
assert( valueIt != enumIt->second.values.end() );
std::string objTypeEnum = valueIt->vkValue;
@ -3756,7 +3731,8 @@ bool VulkanHppGenerator::checkEquivalentSingularConstructor(
auto singularCommandIt =
std::find_if( constructorIts.begin(),
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() )
{
return false;
@ -4030,8 +4006,8 @@ std::string VulkanHppGenerator::constructCallArgumentEnhanced( std::vector<Param
else if ( param.type.isNonConstPointer() &&
( 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
// though they are not!)
// parameter is a non-const pointer (and none of the special pointer types, that are considered const-pointers,
// even though they are not!)
std::string name = startLowerCase( stripPrefix( param.name, "p" ) );
if ( param.len.empty() )
{
@ -6675,9 +6651,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st
assert( typeIt->len == param.name );
continue;
}
else if ( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) {
return pd.len == param.name;
} ) != params.end() )
else if ( std::find_if( params.begin(),
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
assert( param.type.isValue() && ( param.type.type == "uint32_t" ) );
@ -6705,9 +6681,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st
}
else
{
assert( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) {
return pd.name == param.len;
} ) != params.end() );
assert( std::find_if( params.begin(),
params.end(),
[&param]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() );
if ( singular )
{
arguments += argumentType + " const & " + stripPluralS( argumentName );
@ -6902,10 +6878,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList
assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() &&
!destructorParam.optional );
initializationList += "m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( ";
auto constructorParamIt = std::find_if(
constructorIt->second.params.begin(),
auto constructorParamIt = std::find_if( constructorIt->second.params.begin(),
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() )
{
assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() &&
@ -6922,10 +6898,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList
auto structureIt = m_structures.find( constructorParam.type.type );
if ( structureIt != m_structures.end() )
{
auto structureMemberIt = std::find_if(
structureIt->second.members.begin(),
auto structureMemberIt = std::find_if( structureIt->second.members.begin(),
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() )
{
assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() &&
@ -7147,8 +7123,8 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorVector(
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() );
[&lenParts]( MemberData const & md )
{ return md.name == lenParts[1]; } ) != structureIt->second.members.end() );
assert( constructorIt->second.successCodes.size() == 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(),
constructorIt->second.params.end(),
[&lenIt, &handleParamIt]( ParamData const & pd ) {
return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name );
} );
[&lenIt, &handleParamIt]( ParamData const & pd )
{ return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name ); } );
assert( arrayIt != constructorIt->second.params.end() );
vectorSize = startLowerCase( stripPrefix( arrayIt->name, "p" ) ) + ".size()";
}
@ -7357,9 +7332,10 @@ std::string
else
{
assert( param.type.isConstPointer() );
assert( !param.len.empty() && ( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) {
return pd.name == param.len;
} ) != params.end() ) );
assert( !param.len.empty() &&
( std::find_if( params.begin(),
params.end(),
[&param]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ) );
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() &&
param.len.empty() && !param.optional );
assert( std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) {
return pd.len == param.name;
} ) != params.end() );
assert( std::find_if( params.begin(),
params.end(),
[&param]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() );
arguments += "1";
}
encounteredArgument = true;
@ -9677,10 +9653,10 @@ std::string VulkanHppGenerator::constructRAIIHandleSingularConstructorArguments(
auto structureIt = m_structures.find( constructorParam.type.type );
if ( structureIt != m_structures.end() )
{
auto memberIt = std::find_if(
structureIt->second.members.begin(),
auto memberIt = std::find_if( structureIt->second.members.begin(),
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 !defined( NDEBUG )
@ -9970,10 +9946,10 @@ void VulkanHppGenerator::appendStructConstructorsEnhanced( std::string &
std::pair<std::string, StructureData> const & structData,
std::string const & prefix ) const
{
auto memberIts =
findAll( structData.second.members.begin(), structData.second.members.end(), []( MemberData const & md ) {
return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() );
} );
auto memberIts = findAll( structData.second.members.begin(),
structData.second.members.end(),
[]( MemberData const & md )
{ return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() ); } );
if ( !memberIts.empty() )
{
// 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() )
{
// 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 ) {
return sd.second.aliases.find( extendName ) != sd.second.aliases.end();
} );
itExtend = std::find_if( m_structures.begin(),
m_structures.end(),
[extendName]( auto const & sd )
{ return sd.second.aliases.find( extendName ) != sd.second.aliases.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 );
if ( handleIt == m_handles.end() )
{
handleIt = std::find_if(
m_handles.begin(), m_handles.end(), [&typeName]( std::pair<std::string, HandleData> const & hd ) {
return hd.second.alias == typeName;
} );
handleIt = std::find_if( m_handles.begin(),
m_handles.end(),
[&typeName]( std::pair<std::string, HandleData> const & hd )
{ return hd.second.alias == typeName; } );
assert( handleIt != m_handles.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 );
if ( structIt == m_structures.end() )
{
structIt = std::find_if(
m_structures.begin(), m_structures.end(), [&typeName]( std::pair<std::string, StructureData> const & sd ) {
return sd.second.aliases.find( typeName ) != sd.second.aliases.end();
} );
structIt = std::find_if( m_structures.begin(),
m_structures.end(),
[&typeName]( std::pair<std::string, StructureData> const & sd )
{ return sd.second.aliases.find( typeName ) != sd.second.aliases.end(); } );
assert( structIt != m_structures.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
// constructor.
auto compareBool32Alias = []( MemberData const & member ) {
auto compareBool32Alias = []( MemberData const & member )
{
return member.type.type == std::string( "uint32_t" );
};
if ( member.type.type == "VkBool32" )
@ -10664,8 +10642,9 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair<std::string,
// the union member variables
// if there's at least one Vk... type in this union, check for unrestricted unions support
bool needsUnrestrictedUnions =
( std::find_if( structure.second.members.begin(), structure.second.members.end(), []( MemberData const & member ) {
bool needsUnrestrictedUnions = ( std::find_if( structure.second.members.begin(),
structure.second.members.end(),
[]( MemberData const & member ) {
return beginsWith( member.type.type, "Vk" );
} ) != structure.second.members.end() );
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( ( std::find_if( values.begin(),
values.end(),
[&aliasName]( EnumValueData const & evd ) { return evd.vulkanValue == aliasName; } ) !=
values.end() ) ||
[&aliasName]( EnumValueData const & evd )
{ return evd.vulkanValue == aliasName; } ) != values.end() ) ||
( aliases.find( aliasName ) != aliases.end() ),
line,
"unknown enum alias <" + aliasName + ">" );
@ -10757,9 +10736,8 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line,
// only list aliases that map to different vkNames
aliasIt = std::find_if( aliases.begin(),
aliases.end(),
[&vkName]( std::pair<std::string, std::pair<std::string, std::string>> const & aliasEntry ) {
return vkName == aliasEntry.second.second;
} );
[&vkName]( std::pair<std::string, std::pair<std::string, std::string>> const & aliasEntry )
{ return vkName == aliasEntry.second.second; } );
if ( aliasIt == aliases.end() )
{
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 );
auto it = std::find_if( values.begin(), values.end(), [&translatedName]( EnumValueData const & evd ) {
return evd.vkValue == translatedName;
} );
auto it = std::find_if( values.begin(),
values.end(),
[&translatedName]( EnumValueData const & evd ) { return evd.vkValue == translatedName; } );
if ( it == values.end() )
{
values.emplace_back( line, valueName, translatedName, extension, bitpos );
@ -10929,9 +10907,8 @@ void VulkanHppGenerator::checkCorrectness()
{
check( std::find_if( m_handles.begin(),
m_handles.end(),
[&objectTypeValue]( std::pair<std::string, HandleData> const & hd ) {
return hd.second.objTypeEnum == objectTypeValue.vulkanValue;
} ) != m_handles.end(),
[&objectTypeValue]( std::pair<std::string, HandleData> const & hd )
{ return hd.second.objTypeEnum == objectTypeValue.vulkanValue; } ) != m_handles.end(),
objectTypeValue.xmlLine,
"VkObjectType value <" + objectTypeValue.vulkanValue +
"> not specified as \"objtypeenum\" for any handle" );
@ -10966,8 +10943,8 @@ void VulkanHppGenerator::checkCorrectness()
std::string const & selection = data.selection;
check( std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&selection]( EnumValueData const & evd ) { return evd.vulkanValue == selection; } ) !=
enumIt->second.values.end(),
[&selection]( EnumValueData const & evd )
{ return evd.vulkanValue == selection; } ) != enumIt->second.values.end(),
data.xmlLine,
"union member <" + data.name + "> uses selection <" + selection +
"> 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(),
enumIt->second.values.end(),
[&enumValue]( auto const & evd ) { return enumValue == evd.vulkanValue; } ) !=
enumIt->second.values.end(),
[&enumValue]( auto const & evd )
{ return enumValue == evd.vulkanValue; } ) != enumIt->second.values.end(),
member.xmlLine,
"value <" + enumValue + "> for member <" + member.name + "> in structure <" + structure.first +
" 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(); )
{
commandIt =
std::find_if( commandIt, 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 ) {
std::find_if( commandIt,
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();
} ) != cd.second.params.end();
} );
@ -11143,9 +11125,9 @@ std::vector<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
assert( paramIt != destructorIt->second.params.end() );
for ( auto pit = destructorIt->second.params.begin(); valid && pit != destructorIt->second.params.end(); ++pit )
{
valid = ( pit->name == paramIt->len ) ||
( std::find_if(
commandIt->second.params.begin(), commandIt->second.params.end(), [&pit]( ParamData const & pd ) {
valid = ( pit->name == paramIt->len ) || ( std::find_if( commandIt->second.params.begin(),
commandIt->second.params.end(),
[&pit]( ParamData const & pd ) {
return pd.type.type == pit->type.type;
} ) != commandIt->second.params.end() );
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(),
structureIt->second.members.end(),
[&pit]( MemberData const & md ) { return md.type.type == pit->type.type; } ) !=
structureIt->second.members.end();
[&pit]( MemberData const & md )
{ 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
// assert that it's not a vector-size parameter
assert( std::find_if(
vectorParamIndices.begin(), vectorParamIndices.end(), [index]( std::pair<size_t, size_t> const & vpi ) {
return vpi.second == index;
} ) == vectorParamIndices.end() );
assert( std::find_if( vectorParamIndices.begin(),
vectorParamIndices.end(),
[index]( std::pair<size_t, size_t> const & vpi )
{ return vpi.second == index; } ) == vectorParamIndices.end() );
std::map<size_t, size_t>::const_iterator vpit = vectorParamIndices.find( index );
if ( ( vpit == vectorParamIndices.end() ) || twoStep || ( vectorParamIndices.size() > 1 ) ||
@ -11350,9 +11332,10 @@ std::map<size_t, size_t>
{
if ( !it->len.empty() )
{
auto findIt = std::find_if( params.begin(), it, [this, &it]( ParamData const & pd ) {
return ( pd.name == it->len ) || isLenByStructMember( it->len, pd );
} );
auto findIt = std::find_if( params.begin(),
it,
[this, &it]( ParamData const & pd )
{ return ( pd.name == it->len ) || isLenByStructMember( it->len, pd ); } );
if ( findIt < it )
{
@ -11646,6 +11629,32 @@ std::string
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> platforms;
@ -11666,9 +11675,10 @@ std::pair<std::string, std::string> VulkanHppGenerator::getPoolTypeAndName( std:
structIt->second.members.end(),
[]( MemberData const & md ) { return md.name.find( "Pool" ) != std::string::npos; } );
assert( memberIt != structIt->second.members.end() );
assert( std::find_if( std::next( memberIt ), structIt->second.members.end(), []( MemberData const & md ) {
return md.name.find( "Pool" ) != std::string::npos;
} ) == structIt->second.members.end() );
assert( std::find_if( std::next( memberIt ),
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 );
}
@ -11726,9 +11736,9 @@ bool VulkanHppGenerator::isHandleType( std::string const & type ) const
auto it = m_handles.find( type );
if ( it == m_handles.end() )
{
it = std::find_if( m_handles.begin(), m_handles.end(), [&type]( std::pair<std::string, HandleData> const & hd ) {
return hd.second.alias == type;
} );
it = std::find_if( m_handles.begin(),
m_handles.end(),
[&type]( std::pair<std::string, HandleData> const & hd ) { return hd.second.alias == type; } );
}
return ( it != m_handles.end() );
}
@ -11755,8 +11765,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, std::vec
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() );
[&n = nameParts[1]]( MemberData const & md )
{ return md.name == n; } ) != structureIt->second.members.end() );
#endif
return true;
}
@ -11780,8 +11790,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, ParamDat
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() );
[&n = nameParts[1]]( MemberData const & md )
{ return md.name == n; } ) != structureIt->second.members.end() );
#endif
return true;
}
@ -11823,10 +11833,10 @@ bool VulkanHppGenerator::isStructureChainAnchor( std::string const & type ) cons
auto it = m_structures.find( type );
if ( it == m_structures.end() )
{
it = std::find_if(
m_structures.begin(), m_structures.end(), [&type]( std::pair<std::string, StructureData> const & sd ) {
return sd.second.aliases.find( type ) != sd.second.aliases.end();
} );
it = std::find_if( m_structures.begin(),
m_structures.end(),
[&type]( std::pair<std::string, StructureData> const & sd )
{ return sd.second.aliases.find( type ) != sd.second.aliases.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(),
countToVectorMap.end(),
[]( auto const & cvm ) { return 1 < cvm.second.size(); } ) !=
countToVectorMap.end(),
[]( auto const & cvm )
{ return 1 < cvm.second.size(); } ) != countToVectorMap.end(),
countToVectorMap );
}
@ -12444,9 +12454,9 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
bool bitmask = ( type == "bitmask" );
if ( bitmask )
{
auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&name]( auto const & bitmask ) {
return bitmask.second.requirements == name;
} );
auto bitmaskIt = std::find_if( m_bitmasks.begin(),
m_bitmasks.end(),
[&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } );
check( bitmaskIt != m_bitmasks.end(),
line,
"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;
check( std::find_if( m_features.begin(),
m_features.end(),
[&requiresCore]( std::pair<std::string, std::string> const & nameNumber ) {
return nameNumber.second == requiresCore;
} ) != m_features.end(),
[&requiresCore]( std::pair<std::string, std::string> const & nameNumber )
{ return nameNumber.second == requiresCore; } ) != m_features.end(),
line,
"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->second.alias.empty(),
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 );
}
break;
@ -13078,9 +13088,8 @@ void VulkanHppGenerator::readPlatform( tinyxml2::XMLElement const * element )
check( std::find_if( m_platforms.begin(),
m_platforms.end(),
[&protect]( std::pair<std::string, PlatformData> const & p ) {
return p.second.protect == protect;
} ) == m_platforms.end(),
[&protect]( std::pair<std::string, PlatformData> const & p )
{ return p.second.protect == protect; } ) == m_platforms.end(),
line,
"platform protect <" + protect + "> already specified" );
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
// 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
// this external knowledge!
// VkWriteDescriptorSet)! That is, there's not enough information available in vk.xml to decide on that, so we
// need this external knowledge!
static std::set<std::string> mutualExclusiveStructs = { "VkAccelerationStructureBuildGeometryInfoKHR",
"VkWriteDescriptorSet" };
static std::set<std::string> multipleLenStructs = { "VkImageConstraintsInfoFUCHSIA",

4
VulkanHppGenerator.hpp
View File

@ -971,7 +971,9 @@ private:
std::string const & structName,
std::string const & prefix,
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::string getVectorSize( std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices,

646
vulkan/vulkan.hpp
View File

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