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

Merge pull request #978 from asuessenbach/enum

Browse Source 
Correct postfix tag of some enums.
This commit is contained in:
Andreas Süßenbach 2021-06-02 08:34:19 +02:00 committed by GitHub
commit 71c53b678a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 273 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
VulkanHppGenerator.cpp
View File

@ -41,17 +41,16 @@ std::vector<std::string> extractHandleCommands( std::vector<std::string> const &
std::set<std::string> const & handleCommands,
std::set<std::string> & listedCommands );
std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
std::string generateEnumValueName( std::string const & name,
std::string const & prefix,
std::string const & postfix,
std::string generateEnumValueName( std::string const & enumName,
std::string const & valueName,
bool bitmask,
std::string const & tag );
std::set<std::string> const & tags );
std::string generateStandardArray( std::string const & type, std::vector<std::string> const & sizes );
std::map<std::string, std::string> getAttributes( tinyxml2::XMLElement const * element );
template <typename ElementContainer>
std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element );
std::string getEnumPostfix( std::string const & name, std::set<std::string> const & tags, std::string & prefix );
std::string namespacedType( std::string const & type );
std::pair<std::string, std::string>
getEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags );
std::string readTypePostfix( tinyxml2::XMLNode const * node );
std::string readTypePrefix( tinyxml2::XMLNode const * node );
void replaceAll( std::string & str, std::string const & from, std::string const & to );
@ -330,13 +329,20 @@ std::string findTag( std::set<std::string> const & tags, std::string const & nam
return ( tagIt != tags.end() ) ? *tagIt : "";
}
std::string generateEnumValueName( std::string const & name,
std::string const & prefix,
std::string const & postfix,
std::string generateEnumValueName( std::string const & enumName,
std::string const & valueName,
bool bitmask,
std::string const & tag )
std::set<std::string> const & tags )
{
std::string result = "e" + toCamelCase( stripPostfix( stripPrefix( name, prefix ), postfix ) );
std::string prefix, postfix;
std::tie( prefix, postfix ) = getEnumSuffixes( enumName, bitmask, tags );
std::string tag = findTag( tags, valueName, "" );
if ( postfix == "_" + tag )
{
tag = findTag( tags, valueName, postfix );
}
std::string result = "e" + toCamelCase( stripPostfix( stripPrefix( valueName, prefix ), postfix ) );
if ( bitmask )
{
size_t pos = result.find( "Bit" );
@ -385,11 +391,33 @@ std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer con
return childElements;
}
std::string getEnumPostfix( std::string const & name, std::set<std::string> const & tags, std::string & prefix )
std::pair<std::string, std::string>
getEnumSuffixes( std::string const & name, bool bitmask, std::set<std::string> const & tags )
{
std::string postfix;
if ( name != "VkResult" )
std::string prefix, postfix;
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" );
assert( pos != std::string::npos );
std::string shortenedName = name;
shortenedName.erase( pos, strlen( "FlagBits" ) );
std::string tag = findTag( tags, shortenedName );
prefix = toUpperCase( stripPostfix( shortenedName, tag ) ) + "_";
}
else
{
// for a non-bitmask enum, convert the name to upper case
prefix = toUpperCase( name ) + "_";
}
// if the enum name contains a tag move it from the prefix to the postfix to generate correct enum value names.
for ( auto const & tag : tags )
{
@ -406,7 +434,8 @@ std::string getEnumPostfix( std::string const & name, std::set<std::string> cons
}
}
}
return postfix;
return std::make_pair( prefix, postfix );
}
std::pair<std::vector<std::string>, std::string> readModifiers( tinyxml2::XMLNode const * node )
@ -1004,9 +1033,9 @@ void VulkanHppGenerator::appendBitmask( std::string & str,
{
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( value.extension );
std::string valueName = generateEnumValueName( "Vk" + name, value.name, true, m_tags );
allFlags += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " +
( encounteredFlag ? "| " : " " ) + bitmaskType + "( " + enumName + "::" + value.translatedName +
" )";
( encounteredFlag ? "| " : " " ) + bitmaskType + "( " + enumName + "::" + valueName + " )";
encounteredFlag = true;
previousEnter = enter;
previousLeave = leave;
@ -1092,8 +1121,9 @@ void VulkanHppGenerator::appendBitmaskToStringFunction( std::string &
{
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( evd.extension );
str += enter + " if ( value & " + enumName + "::" + evd.translatedName + " ) result += \"" +
evd.translatedName.substr( 1 ) + " | \";\n" + leave;
std::string valueName = generateEnumValueName( "Vk" + enumName, evd.name, true, m_tags );
str += enter + " if ( value & " + enumName + "::" + valueName + " ) result += \"" + valueName.substr( 1 ) +
" | \";\n" + leave;
}
}
str += " return \"{ \" + result.substr(0, result.size() - 3) + \" }\";\n";
@ -2646,6 +2676,7 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
}
std::string enumList, previousEnter, previousLeave;
std::set<std::string> valueNames;
for ( auto const & value : enumData.second.values )
{
std::string enter, leave;
@ -2654,7 +2685,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
{
enumList += previousLeave + enter;
}
enumList += " " + value.translatedName + " = " + value.name + ",\n";
std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask, m_tags );
enumList += " " + valueName + " = " + value.name + ",\n";
assert( valueNames.find( valueName ) == valueNames.end() );
valueNames.insert( valueName );
previousEnter = enter;
previousLeave = leave;
@ -2663,11 +2697,16 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
for ( auto const & alias : enumData.second.aliases )
{
std::string aliasName =
generateEnumValueName( enumData.second.alias.empty() ? enumData.first : enumData.second.alias,
alias.first,
enumData.second.isBitmask,
m_tags );
// 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.translatedName == evd.translatedName; } ) == enumData.second.values.end() )
if ( std::find_if( valueNames.begin(),
valueNames.end(),
[&aliasName]( std::string const & valueName )
{ return aliasName == valueName; } ) == valueNames.end() )
{
#if !defined( NDEBUG )
auto enumIt = std::find_if( enumData.second.values.begin(),
@ -2684,7 +2723,7 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
assert( enumIt != enumData.second.values.end() );
assert( enumIt->extension.empty() || generateProtection( enumIt->extension ).first.empty() );
#endif
enumList += " " + alias.second.translatedName + " = " + alias.first + ",\n";
enumList += " " + aliasName + " = " + alias.first + ",\n";
}
}
if ( enumList.empty() )
@ -2780,11 +2819,13 @@ void VulkanHppGenerator::appendEnums( std::string & str ) const
void VulkanHppGenerator::appendEnumInitializer( std::string & str,
TypeInfo const & type,
std::vector<std::string> const & arraySizes,
std::vector<EnumValueData> const & values ) const
std::vector<EnumValueData> const & values,
bool bitmask ) const
{
// enum arguments might need special initialization
assert( type.prefix.empty() && !values.empty() );
std::string value = "VULKAN_HPP_NAMESPACE::" + stripPrefix( type.type, "Vk" ) + "::" + values.front().translatedName;
std::string valueName = generateEnumValueName( type.type, values.front().name, bitmask, m_tags );
std::string value = "VULKAN_HPP_NAMESPACE::" + stripPrefix( type.type, "Vk" ) + "::" + valueName;
if ( arraySizes.empty() )
{
str += value;
@ -2837,8 +2878,8 @@ void VulkanHppGenerator::appendEnumToString( std::string &
{
str += previousLeave + enter;
}
str += " case " + enumName + "::" + value.translatedName + " : return \"" +
value.translatedName.substr( 1 ) + "\";\n";
std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask, m_tags );
str += " case " + enumName + "::" + valueName + " : return \"" + valueName.substr( 1 ) + "\";\n";
previousEnter = enter;
previousLeave = leave;
}
@ -3317,13 +3358,14 @@ ${CppTypeFromDebugReportObjectTypeEXT}
${usingAlias}${leave})";
std::string className = stripPrefix( handleData.first, "Vk" );
std::string valueName = handleData.second.objTypeEnum;
valueName = valueName.replace( 3, 0, "DEBUG_REPORT_" ) + "_EXT";
auto enumIt = m_enums.find( "VkDebugReportObjectTypeEXT" );
assert( enumIt != m_enums.end() );
auto valueIt =
std::find_if( enumIt->second.values.begin(),
auto valueIt = std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&className]( EnumValueData const & evd ) { return evd.translatedName == "e" + className; } );
[&valueName]( EnumValueData const & evd ) { return valueName == evd.name; } );
static const std::string cppTypeFromDebugReportObjectTypeEXTTemplate = R"(
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::e${className}>
@ -3335,8 +3377,9 @@ ${usingAlias}${leave})";
( valueIt != enumIt->second.values.end() )
? replaceWithMap( cppTypeFromDebugReportObjectTypeEXTTemplate, { { "className", className } } )
: "";
std::string debugReportObjectType =
( valueIt != enumIt->second.values.end() ) ? valueIt->translatedName : "eUnknown";
std::string debugReportObjectType = ( valueIt != enumIt->second.values.end() )
? generateEnumValueName( enumIt->first, valueIt->name, false, m_tags )
: "eUnknown";
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( handleData.first, !handleData.second.alias.empty() );
@ -3364,7 +3407,7 @@ ${usingAlias}${leave})";
{ "enter", enter },
{ "leave", leave },
{ "memberName", startLowerCase( stripPrefix( handleData.first, "Vk" ) ) },
{ "objTypeEnum", valueIt->translatedName },
{ "objTypeEnum", generateEnumValueName( enumIt->first, valueIt->name, false, m_tags ) },
{ "usingAlias", usingAlias } } );
}
@ -3649,18 +3692,19 @@ ${enter} class ${className} : public SystemError
};
${leave})";
auto enumData = m_enums.find( "VkResult" );
for ( auto const & value : enumData->second.values )
auto enumIt = m_enums.find( "VkResult" );
for ( auto const & value : enumIt->second.values )
{
if ( beginsWith( value.translatedName, "eError" ) )
if ( beginsWith( value.name, "VK_ERROR" ) )
{
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( value.extension );
std::string valueName = generateEnumValueName( enumIt->first, value.name, false, m_tags );
str += replaceWithMap( templateString,
{ { "className", stripPrefix( value.translatedName, "eError" ) + "Error" },
{ { "className", stripPrefix( valueName, "eError" ) + "Error" },
{ "enter", enter },
{ "enumName", stripPrefix( enumData->first, "Vk" ) },
{ "enumMemberName", value.translatedName },
{ "enumName", stripPrefix( enumIt->first, "Vk" ) },
{ "enumMemberName", valueName },
{ "leave", leave } } );
}
}
@ -3703,16 +3747,18 @@ void VulkanHppGenerator::appendRAIIHandle( std::string &
enumIt->second.values.end(),
[&handle]( EnumValueData const & evd ) { return evd.name == handle.second.objTypeEnum; } );
assert( valueIt != enumIt->second.values.end() );
std::string objTypeEnum = valueIt->translatedName;
std::string objTypeEnum = generateEnumValueName( enumIt->first, valueIt->name, false, m_tags );
enumIt = m_enums.find( "VkDebugReportObjectTypeEXT" );
assert( enumIt != m_enums.end() );
valueIt =
std::find_if( enumIt->second.values.begin(),
std::string valueName = handle.second.objTypeEnum;
valueName = valueName.replace( 3, 0, "DEBUG_REPORT_" ) + "_EXT";
valueIt = std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&handleType]( EnumValueData const & evd ) { return evd.translatedName == "e" + handleType; } );
std::string debugReportObjectType =
( valueIt != enumIt->second.values.end() ) ? valueIt->translatedName : "eUnknown";
[&valueName]( EnumValueData const & evd ) { return valueName == evd.name; } );
std::string debugReportObjectType = ( valueIt != enumIt->second.values.end() )
? generateEnumValueName( enumIt->first, valueIt->name, false, m_tags )
: "eUnknown";
std::string dispatcherType =
( ( handle.first == "VkDevice" ) ||
@ -10457,7 +10503,8 @@ bool VulkanHppGenerator::appendStructConstructorArgument( std::string & str
auto enumIt = m_enums.find( memberData.type.type );
if ( enumIt != m_enums.end() && memberData.type.postfix.empty() )
{
appendEnumInitializer( str, memberData.type, memberData.arraySizes, enumIt->second.values );
appendEnumInitializer(
str, memberData.type, memberData.arraySizes, enumIt->second.values, enumIt->second.isBitmask );
}
else
{
@ -10502,14 +10549,15 @@ std::string VulkanHppGenerator::appendStructMembers( std::string &
assert( enumIt != m_enums.end() );
{
std::string enumValue = member.values.front();
auto nameIt = std::find_if( enumIt->second.values.begin(),
auto valueIt = std::find_if( enumIt->second.values.begin(),
enumIt->second.values.end(),
[&enumValue]( EnumValueData const & evd ) { return enumValue == evd.name; } );
assert( nameIt != enumIt->second.values.end() );
str += " = " + stripPrefix( member.type.type, "Vk" ) + "::" + nameIt->translatedName;
assert( valueIt != enumIt->second.values.end() );
std::string valueName = generateEnumValueName( enumIt->first, valueIt->name, enumIt->second.isBitmask, m_tags );
str += " = " + stripPrefix( member.type.type, "Vk" ) + "::" + valueName;
if ( member.name == "sType" )
{
sTypeValue = nameIt->translatedName;
sTypeValue = valueName;
}
}
}
@ -10528,7 +10576,7 @@ std::string VulkanHppGenerator::appendStructMembers( std::string &
auto enumIt = m_enums.find( member.type.type );
if ( member.arraySizes.empty() && ( enumIt != m_enums.end() ) && member.type.postfix.empty() )
{
appendEnumInitializer( str, member.type, member.arraySizes, enumIt->second.values );
appendEnumInitializer( str, member.type, member.arraySizes, enumIt->second.values, enumIt->second.isBitmask );
}
else
{
@ -10866,7 +10914,7 @@ void VulkanHppGenerator::appendStructureChainValidation( std::string & str )
void VulkanHppGenerator::appendThrowExceptions( std::string & str ) const
{
auto enumData = m_enums.find( "VkResult" );
auto enumIt = m_enums.find( "VkResult" );
str +=
"\n"
@ -10874,14 +10922,15 @@ void VulkanHppGenerator::appendThrowExceptions( std::string & str ) const
" {\n"
" switch ( result )\n"
" {\n";
for ( auto const & value : enumData->second.values )
for ( auto const & value : enumIt->second.values )
{
if ( beginsWith( value.translatedName, "eError" ) )
if ( beginsWith( value.name, "VK_ERROR" ) )
{
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( value.extension );
str += enter + " case Result::" + value.translatedName + ": throw " +
stripPrefix( value.translatedName, "eError" ) + "Error( message );\n" + leave;
std::string valueName = generateEnumValueName( enumIt->first, value.name, false, m_tags );
str += enter + " case Result::" + valueName + ": throw " + stripPrefix( valueName, "eError" ) +
"Error( message );\n" + leave;
}
}
str +=
@ -11101,49 +11150,25 @@ void VulkanHppGenerator::appendUniqueTypes( std::string & str,
str += "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/\n";
}
void VulkanHppGenerator::EnumData::addEnumAlias( int line,
std::string const & name,
std::string const & aliasName,
std::string const & vkName )
void VulkanHppGenerator::EnumData::addEnumAlias( int line, std::string const & name, std::string const & aliasName )
{
auto aliasIt = aliases.find( name );
check( ( aliasIt == aliases.end() ) || ( aliasIt->second.name == aliasName ),
line,
"enum alias <" + name + "> already listed for a different enum value" );
// only list aliases that map to different vkNames
aliasIt = std::find_if( aliases.begin(),
aliases.end(),
[&vkName]( std::pair<std::string, EnumAliasData> const & aliasEntry )
{ return vkName == aliasEntry.second.translatedName; } );
if ( aliasIt == aliases.end() )
{
aliases.insert( std::make_pair( name, EnumAliasData( aliasName, vkName, line ) ) );
}
aliases.insert( std::make_pair( name, EnumAliasData( aliasName, line ) ) );
}
void VulkanHppGenerator::EnumData::addEnumValue( int line,
std::string const & valueName,
bool bitmask,
bool bitpos,
std::string const & prefix,
std::string const & postfix,
std::string const & extension,
std::string const & tag )
std::string const & extension )
{
std::string translatedName = generateEnumValueName( valueName, prefix, postfix, bitmask, tag );
auto it =
std::find_if( values.begin(),
values.end(),
[&translatedName]( EnumValueData const & evd ) { return evd.translatedName == translatedName; } );
if ( it == values.end() )
auto valueIt = std::find_if(
values.begin(), values.end(), [&valueName]( EnumValueData const & evd ) { return evd.name == valueName; } );
if ( valueIt == values.end() )
{
values.emplace_back( line, valueName, extension, bitpos, translatedName );
}
else
{
check( it->name == valueName, line, "enum value <" + valueName + "> maps to same C++-name as <" + it->name + ">" );
values.emplace_back( line, valueName, extension, bitpos );
}
}
@ -11304,7 +11329,7 @@ void VulkanHppGenerator::checkCorrectness()
}
for ( auto const & objectTypeValue : objectTypeIt->second.values )
{
if ( objectTypeValue.translatedName != "eUnknown" )
if ( objectTypeValue.name != "VK_OBJECT_TYPE_UNKNOWN" )
{
check( std::find_if( m_handles.begin(),
m_handles.end(),
@ -11793,26 +11818,27 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
std::set<std::string> seenCppTypes;
for ( auto const & value : indexType->second.values )
{
std::string valueName = generateEnumValueName( indexType->first, value.name, false, m_tags );
std::string cppType;
if ( beginsWith( value.translatedName, "eUint8" ) )
if ( beginsWith( valueName, "eUint8" ) )
{
cppType = "uint8_t";
}
else if ( beginsWith( value.translatedName, "eUint16" ) )
else if ( beginsWith( valueName, "eUint16" ) )
{
cppType = "uint16_t";
}
else if ( beginsWith( value.translatedName, "eUint32" ) )
else if ( beginsWith( valueName, "eUint32" ) )
{
cppType = "uint32_t";
}
else if ( beginsWith( value.translatedName, "eUint64" ) )
else if ( beginsWith( valueName, "eUint64" ) )
{
cppType = "uint64_t"; // No extension for this currently
}
else
{
assert( beginsWith( value.translatedName, "eNone" ) );
assert( beginsWith( valueName, "eNone" ) );
}
if ( !cppType.empty() )
@ -11830,7 +11856,7 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
">\n"
" {\n"
" static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::" +
value.translatedName +
valueName +
";\n"
" };\n";
}
@ -11839,7 +11865,7 @@ void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
"\n"
" template <>\n"
" struct CppType<IndexType, IndexType::" +
value.translatedName +
valueName +
">\n"
" {\n"
" using Type = " +
@ -12083,32 +12109,6 @@ 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::string VulkanHppGenerator::getPlatform( std::string const & extension ) const
{
auto extensionIt = m_extensions.find( extension );
@ -12714,29 +12714,23 @@ void VulkanHppGenerator::readDefine( tinyxml2::XMLElement const *
}
void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const * element,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix )
std::map<std::string, EnumData>::iterator enumIt )
{
std::map<std::string, std::string> attributes = getAttributes( element );
auto aliasIt = attributes.find( "alias" );
if ( aliasIt != attributes.end() )
{
readEnumAlias( element, attributes, enumData, bitmask, prefix, postfix );
readEnumAlias( element, attributes, enumIt->second );
}
else
{
readEnum( element, attributes, enumData, bitmask, prefix, postfix );
readEnum( element, attributes, enumIt );
}
}
void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix )
std::map<std::string, EnumData>::iterator enumIt )
{
int line = element->GetLineNum();
checkAttributes( line, attributes, { { "name", {} } }, { { "bitpos", {} }, { "comment", {} }, { "value", {} } } );
@ -12758,22 +12752,19 @@ void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const * el
value = attribute.second;
}
}
std::string prefix = getEnumSuffixes( enumIt->first, enumIt->second.isBitmask, m_tags ).first;
warn( beginsWith( name, prefix ),
line,
"encountered enum value <" + name + "> that does not begin with expected prefix <" + prefix + ">" );
std::string tag = findTag( m_tags, name, postfix );
check( bitpos.empty() ^ value.empty(), line, "invalid set of attributes for enum <" + name + ">" );
enumData.addEnumValue( line, name, bitmask, !bitpos.empty(), prefix, postfix, "", tag );
enumIt->second.addEnumValue( line, name, !bitpos.empty(), "" );
}
void VulkanHppGenerator::readEnumAlias( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix )
EnumData & enumData )
{
int line = element->GetLineNum();
checkAttributes( line, attributes, { { "alias", {} }, { "name", {} } }, { { "comment", {} } } );
@ -12795,8 +12786,7 @@ void VulkanHppGenerator::readEnumAlias( tinyxml2::XMLElement const *
}
assert( !name.empty() );
std::string tag = findTag( m_tags, name, postfix );
enumData.addEnumAlias( line, name, alias, generateEnumValueName( name, prefix, postfix, bitmask, tag ) );
enumData.addEnumAlias( line, name, alias );
}
void VulkanHppGenerator::readEnumConstant( tinyxml2::XMLElement const * element )
@ -12876,14 +12866,15 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
check( !type.empty(), line, "enum without type" );
// get the EnumData entry in enum map
std::map<std::string, EnumData>::iterator it = m_enums.find( name );
check( it != m_enums.end(), line, "enum <" + name + "> is not listed as enum in the types section" );
check( it->second.values.empty(), line, "enum <" + name + "> already holds values" );
std::map<std::string, EnumData>::iterator enumIt = m_enums.find( name );
check( enumIt != m_enums.end(), line, "enum <" + name + "> is not listed as enum in the types section" );
check( enumIt->second.values.empty(), line, "enum <" + name + "> already holds values" );
// mark it as a bitmask, if it is one
bool bitmask = ( type == "bitmask" );
if ( bitmask )
{
check( name.find( "FlagBits" ) != std::string::npos, line, "bitmask <" + name + "> does not contain <FlagBits>" );
auto bitmaskIt = std::find_if( m_bitmasks.begin(),
m_bitmasks.end(),
[&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } );
@ -12895,10 +12886,8 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
"enum <" + name + "> is marked with bitwidth <64> but corresponding bitmask <" + bitmaskIt->first +
"> is not of type <VkFlags64>" );
}
it->second.isBitmask = bitmask;
enumIt->second.isBitmask = bitmask;
std::string prefix = getEnumPrefix( line, name, bitmask );
std::string postfix = getEnumPostfix( name, m_tags, prefix );
// read the names of the enum values
for ( auto child : children )
{
@ -12909,7 +12898,7 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element )
}
else if ( value == "enum" )
{
readEnum( child, it->second, bitmask, prefix, postfix );
readEnum( child, enumIt );
}
}
}
@ -13031,7 +13020,7 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
for ( auto child : children )
{
readExtensionRequire( child, pitb.first, tag );
readExtensionRequire( child, pitb.first );
}
}
}
@ -13144,8 +13133,7 @@ void VulkanHppGenerator::readExtensionDisabledType( tinyxml2::XMLElement const *
}
void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt,
std::string const & tag )
std::map<std::string, ExtensionData>::iterator extensionIt )
{
int line = element->GetLineNum();
std::map<std::string, std::string> attributes = getAttributes( element );
@ -13182,7 +13170,7 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
}
else if ( value == "enum" )
{
readRequireEnum( child, extensionIt->first, tag );
readRequireEnum( child, extensionIt->first );
}
else if ( value == "type" )
{
@ -13340,7 +13328,7 @@ void VulkanHppGenerator::readFeatureRequire( tinyxml2::XMLElement const *
}
else if ( value == "enum" )
{
readRequireEnum( child, "", "" );
readRequireEnum( child, "" );
}
else if ( value == "type" )
{
@ -13697,25 +13685,22 @@ void VulkanHppGenerator::readRegistry( tinyxml2::XMLElement const * element )
}
}
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
std::string const & extension,
std::string const & tag )
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension )
{
std::map<std::string, std::string> attributes = getAttributes( element );
if ( attributes.find( "alias" ) != attributes.end() )
{
readRequireEnumAlias( element, attributes, tag );
readRequireEnumAlias( element, attributes );
}
else
{
readRequireEnum( element, attributes, extension, tag );
readRequireEnum( element, attributes, extension );
}
}
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
std::string const & extension,
std::string const & tag )
std::string const & extension )
{
int line = element->GetLineNum();
checkAttributes( line,
@ -13773,16 +13758,12 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
auto enumIt = m_enums.find( extends );
check( enumIt != m_enums.end(), line, "feature extends unknown enum <" + extends + ">" );
std::string prefix = getEnumPrefix( element->GetLineNum(), enumIt->first, enumIt->second.isBitmask );
std::string postfix = getEnumPostfix( enumIt->first, m_tags, prefix );
// add this enum name to the list of values
check( bitpos.empty() + offset.empty() + value.empty() == 2,
line,
"exactly one out of bitpos = <" + bitpos + ">, offset = <" + offset + ">, and value = <" + value +
"> are supposed to be empty" );
enumIt->second.addEnumValue(
element->GetLineNum(), name, enumIt->second.isBitmask, !bitpos.empty(), prefix, postfix, extension, tag );
enumIt->second.addEnumValue( element->GetLineNum(), name, !bitpos.empty(), extension );
}
else if ( value.empty() )
{
@ -13791,8 +13772,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
}
void VulkanHppGenerator::readRequireEnumAlias( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
std::string const & tag )
std::map<std::string, std::string> const & attributes )
{
int line = element->GetLineNum();
checkAttributes( line, attributes, { { "alias", {} }, { "extends", {} }, { "name", {} } }, { { "comment", {} } } );
@ -13818,22 +13798,8 @@ void VulkanHppGenerator::readRequireEnumAlias( tinyxml2::XMLElement const *
auto enumIt = m_enums.find( extends );
check( enumIt != m_enums.end(), line, "feature extends unknown enum <" + extends + ">" );
std::string prefix = getEnumPrefix( element->GetLineNum(), enumIt->first, enumIt->second.isBitmask );
std::string postfix = getEnumPostfix( enumIt->first, m_tags, prefix );
// add this enum name to the list of aliases
std::string valueName = generateEnumValueName( name, prefix, postfix, enumIt->second.isBitmask, tag );
if ( !enumIt->second.alias.empty() )
{
prefix = getEnumPrefix( element->GetLineNum(), enumIt->second.alias, enumIt->second.isBitmask );
postfix = getEnumPostfix( enumIt->second.alias, m_tags, prefix );
if ( endsWith( name, postfix ) )
{
valueName = generateEnumValueName( name, prefix, postfix, enumIt->second.isBitmask, tag );
}
}
enumIt->second.addEnumAlias( line, name, alias, valueName );
enumIt->second.addEnumAlias( line, name, alias );
}
void VulkanHppGenerator::readRequires( tinyxml2::XMLElement const * element,

64
VulkanHppGenerator.hpp
View File

@ -132,48 +132,29 @@ private:
struct EnumAliasData
{
EnumAliasData( std::string const & name_, std::string const & translatedName_, int line )
: name( name_ ), translatedName( translatedName_ ), xmlLine( line )
{}
EnumAliasData( std::string const & name_, int line ) : name( name_ ), xmlLine( line ) {}
std::string name; // the original name
std::string translatedName; // the name translated into vk-namespace
std::string name;
int xmlLine;
};
struct EnumValueData
{
EnumValueData( int line,
std::string const & name_,
std::string const & extension_,
bool singleBit_,
std::string const & translatedName_ )
: name( name_ )
, extension( extension_ )
, singleBit( singleBit_ )
, translatedName( translatedName_ )
, xmlLine( line )
EnumValueData( int line, std::string const & name_, std::string const & extension_, bool singleBit_ )
: name( name_ ), extension( extension_ ), singleBit( singleBit_ ), xmlLine( line )
{}
std::string name; // the original name
std::string name;
std::string extension;
bool singleBit;
std::string translatedName; // the name translated into vk-namespace
int xmlLine;
};
struct EnumData
{
EnumData( int line ) : xmlLine( line ) {}
void addEnumAlias( int line, std::string const & name, std::string const & alias, std::string const & vkName );
void addEnumValue( int line,
std::string const & valueName,
bool bitmask,
bool bitpos,
std::string const & prefix,
std::string const & postfix,
std::string const & extension,
std::string const & tag );
void addEnumAlias( int line, std::string const & name, std::string const & alias );
void addEnumValue( int line, std::string const & valueName, bool bitpos, std::string const & extension );
std::string alias; // alias for this enum
std::map<std::string, EnumAliasData> aliases;
@ -519,7 +500,8 @@ private:
void appendEnumInitializer( std::string & str,
TypeInfo const & type,
std::vector<std::string> const & arraySizes,
std::vector<EnumValueData> const & values ) const;
std::vector<EnumValueData> const & values,
bool bitmask ) const;
void appendEnumToString( std::string & str, std::pair<std::string, EnumData> const & enumData ) const;
std::string appendFunctionBodyEnhancedLocalReturnVariable( std::string & str,
std::string const & indentation,
@ -1123,7 +1105,6 @@ private:
std::string const & structName,
std::string const & prefix,
bool mutualExclusiveLens ) const;
std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) const;
std::string getPlatform( std::string const & extension ) const;
std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
std::string getVectorSize( std::vector<ParamData> const & params,
@ -1150,23 +1131,13 @@ private:
void readCommands( tinyxml2::XMLElement const * element );
std::string readComment( tinyxml2::XMLElement const * element );
void readDefine( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
void readEnum( tinyxml2::XMLElement const * element,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix );
void readEnum( tinyxml2::XMLElement const * element, std::map<std::string, EnumData>::iterator enumIt );
void readEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix );
std::map<std::string, EnumData>::iterator enumIt );
void readEnumAlias( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
EnumData & enumData,
bool bitmask,
std::string const & prefix,
std::string const & postfix );
EnumData & enumData );
void readEnumConstant( tinyxml2::XMLElement const * element );
void readEnums( tinyxml2::XMLElement const * element );
void readExtension( tinyxml2::XMLElement const * element );
@ -1174,8 +1145,7 @@ private:
void readExtensionDisabledRequire( tinyxml2::XMLElement const * element );
void readExtensionDisabledType( tinyxml2::XMLElement const * element );
void readExtensionRequire( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt,
std::string const & tag );
std::map<std::string, ExtensionData>::iterator extensionIt );
void readExtensionRequireCommand( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt );
void readExtensionRequireType( tinyxml2::XMLElement const * element,
@ -1194,14 +1164,12 @@ private:
void readPlatform( tinyxml2::XMLElement const * element );
void readPlatforms( tinyxml2::XMLElement const * element );
void readRegistry( tinyxml2::XMLElement const * element );
void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension, std::string const & tag );
void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extension );
void readRequireEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
std::string const & extension,
std::string const & tag );
std::string const & extension );
void readRequireEnumAlias( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes,
std::string const & tag );
std::map<std::string, std::string> const & attributes );
void readRequires( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
void readSPIRVCapability( tinyxml2::XMLElement const * element );
void readSPIRVCapabilityEnable( tinyxml2::XMLElement const * element );

173
vulkan/vulkan.hpp
View File

@ -6394,8 +6394,8 @@ namespace VULKAN_HPP_NAMESPACE
eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,
eCommandBufferSubmitInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR,
ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR,
eQueueFamilyCheckpointProperties2Nv = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
eCheckpointData2Nv = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
eQueueFamilyCheckpointProperties2NV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
eCheckpointData2NV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR =
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR,
ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV =
@ -7269,8 +7269,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eCommandBufferSubmitInfoKHR: return "CommandBufferSubmitInfoKHR";
case StructureType::ePhysicalDeviceSynchronization2FeaturesKHR:
return "PhysicalDeviceSynchronization2FeaturesKHR";
case StructureType::eQueueFamilyCheckpointProperties2Nv: return "QueueFamilyCheckpointProperties2Nv";
case StructureType::eCheckpointData2Nv: return "CheckpointData2Nv";
case StructureType::eQueueFamilyCheckpointProperties2NV: return "QueueFamilyCheckpointProperties2NV";
case StructureType::eCheckpointData2NV: return "CheckpointData2NV";
case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR:
return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR";
case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV:
@ -10521,8 +10521,7 @@ namespace VULKAN_HPP_NAMESPACE
eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE,
eMoltenvk = VK_DRIVER_ID_MOLTENVK,
eCoreaviProprietary = VK_DRIVER_ID_COREAVI_PROPRIETARY,
eJuiceProprietary = VK_DRIVER_ID_JUICE_PROPRIETARY,
eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
eJuiceProprietary = VK_DRIVER_ID_JUICE_PROPRIETARY
};
using DriverIdKHR = DriverId;
@ -12641,18 +12640,18 @@ namespace VULKAN_HPP_NAMESPACE
eVideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
eVideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
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,
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,
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
};
@ -12689,15 +12688,15 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineStageFlagBits2KHR::eVideoDecode: return "VideoDecode";
case PipelineStageFlagBits2KHR::eVideoEncode: return "VideoEncode";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt";
case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt";
case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv";
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";
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 ) ) + " )";
}
}
@ -12731,20 +12730,20 @@ namespace VULKAN_HPP_NAMESPACE
eVideoEncodeRead = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR,
eVideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
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,
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
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 )
@ -12778,17 +12777,17 @@ namespace VULKAN_HPP_NAMESPACE
case AccessFlagBits2KHR::eVideoEncodeRead: return "VideoEncodeRead";
case AccessFlagBits2KHR::eVideoEncodeWrite: return "VideoEncodeWrite";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
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::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";
case AccessFlagBits2KHR::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT";
case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -19193,14 +19192,14 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| VkFlags64( PipelineStageFlagBits2KHR::eVideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::eVideoEncode )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) |
VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) |
VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) |
| 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 )
VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessEXT ) |
VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNV ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNV )
};
};
@ -19290,24 +19289,24 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & PipelineStageFlagBits2KHR::eVideoEncode )
result += "VideoEncode | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt )
result += "TransformFeedbackExt | ";
if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt )
result += "ConditionalRenderingExt | ";
if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv )
result += "CommandPreprocessNv | ";
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 | ";
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 ) + " }";
}
@ -19334,17 +19333,17 @@ namespace VULKAN_HPP_NAMESPACE
| VkFlags64( AccessFlagBits2KHR::eVideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoDecodeWrite ) |
VkFlags64( AccessFlagBits2KHR::eVideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoEncodeWrite )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) |
VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) |
VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) |
VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) |
VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) |
VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) |
| 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 )
VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadEXT ) |
VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT )
};
};
@ -19433,28 +19432,28 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & AccessFlagBits2KHR::eVideoEncodeWrite )
result += "VideoEncodeWrite | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
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::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 | ";
if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadEXT )
result += "FragmentDensityMapReadEXT | ";
if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentEXT )
result += "ColorAttachmentReadNoncoherentEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -29108,7 +29107,7 @@ namespace VULKAN_HPP_NAMESPACE
struct CheckpointData2NV
{
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointData2Nv;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointData2NV;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR CheckpointData2NV( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage_ = {},
@ -29159,7 +29158,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCheckpointData2Nv;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCheckpointData2NV;
void * pNext = {};
VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage = {};
void * pCheckpointMarker = {};
@ -29169,7 +29168,7 @@ namespace VULKAN_HPP_NAMESPACE
static_assert( std::is_standard_layout<CheckpointData2NV>::value, "struct wrapper is not a standard layout!" );
template <>
struct CppType<StructureType, StructureType::eCheckpointData2Nv>
struct CppType<StructureType, StructureType::eCheckpointData2NV>
{
using Type = CheckpointData2NV;
};
@ -93488,7 +93487,7 @@ namespace VULKAN_HPP_NAMESPACE
{
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
StructureType::eQueueFamilyCheckpointProperties2Nv;
StructureType::eQueueFamilyCheckpointProperties2NV;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV(
@ -93540,7 +93539,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyCheckpointProperties2Nv;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyCheckpointProperties2NV;
void * pNext = {};
VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR checkpointExecutionStageMask = {};
};
@ -93550,7 +93549,7 @@ namespace VULKAN_HPP_NAMESPACE
"struct wrapper is not a standard layout!" );
template <>
struct CppType<StructureType, StructureType::eQueueFamilyCheckpointProperties2Nv>
struct CppType<StructureType, StructureType::eQueueFamilyCheckpointProperties2NV>
{
using Type = QueueFamilyCheckpointProperties2NV;
};