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

Gather commands and types per require-block in features and extensions

Browse Source
This commit is contained in:
asuessenbach 2021-07-21 17:09:21 +02:00
parent 710c052892
commit 4a3c6d024d
3 changed files with 600 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

341
VulkanHppGenerator.cpp
View File

@ -50,9 +50,6 @@ template <typename ElementContainer>
std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element ); std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element );
void replaceAll( std::string & str, std::string const & from, std::string const & to ); void replaceAll( std::string & str, std::string const & from, std::string const & to );
std::string replaceWithMap( std::string const & input, std::map<std::string, std::string> replacements ); std::string replaceWithMap( std::string const & input, std::map<std::string, std::string> replacements );
std::vector<std::string> selectCommandsByHandle( std::vector<std::string> const & commands,
std::set<std::string> const & handleCommands,
std::set<std::string> & listedCommands );
std::string startLowerCase( std::string const & input ); std::string startLowerCase( std::string const & input );
std::string startUpperCase( std::string const & input ); std::string startUpperCase( std::string const & input );
std::string stripPostfix( std::string const & value, std::string const & postfix ); std::string stripPostfix( std::string const & value, std::string const & postfix );
@ -97,11 +94,11 @@ VulkanHppGenerator::VulkanHppGenerator( tinyxml2::XMLDocument const & document )
// some "FlagBits" enums are not specified, but needed for our "Flags" handling -> add them here // some "FlagBits" enums are not specified, but needed for our "Flags" handling -> add them here
for ( auto & feature : m_features ) for ( auto & feature : m_features )
{ {
addMissingFlagBits( feature.second.types, feature.first ); addMissingFlagBits( feature.second.requireData, feature.first );
} }
for ( auto & ext : m_extensions ) for ( auto & ext : m_extensions )
{ {
addMissingFlagBits( ext.second.types, ext.first ); addMissingFlagBits( ext.second.requireData, ext.first );
} }
// determine the extensionsByNumber map // determine the extensionsByNumber map
@ -152,11 +149,11 @@ ${bitmasks}
std::set<std::string> listedBitmasks; std::set<std::string> listedBitmasks;
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
bitmasks += generateBitmasks( feature.second.types, listedBitmasks, feature.first ); bitmasks += generateBitmasks( feature.second.requireData, listedBitmasks, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
bitmasks += generateBitmasks( extIt.second->second.types, listedBitmasks, extIt.second->first ); bitmasks += generateBitmasks( extIt.second->second.requireData, listedBitmasks, extIt.second->first );
} }
return replaceWithMap( bitmasksTemplate, { { "bitmasks", bitmasks } } ); return replaceWithMap( bitmasksTemplate, { { "bitmasks", bitmasks } } );
@ -176,12 +173,12 @@ ${commandDefinitions}
std::set<std::string> listedCommands; // some commands are listed with more than one extension! std::set<std::string> listedCommands; // some commands are listed with more than one extension!
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
commandDefinitions += generateCommandDefinitions( feature.second.commands, listedCommands, feature.first ); commandDefinitions += generateCommandDefinitions( feature.second.requireData, listedCommands, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
commandDefinitions += commandDefinitions +=
generateCommandDefinitions( extIt.second->second.commands, listedCommands, extIt.second->first ); generateCommandDefinitions( extIt.second->second.requireData, listedCommands, extIt.second->first );
} }
return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } ); return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } );
@ -281,7 +278,7 @@ ${deviceCommandAssignments}
std::set<std::string> listedCommands; // some commands are listed with more than one extension! std::set<std::string> listedCommands; // some commands are listed with more than one extension!
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
appendDispatchLoaderDynamicCommands( feature.second.commands, appendDispatchLoaderDynamicCommands( feature.second.requireData,
listedCommands, listedCommands,
feature.first, feature.first,
commandMembers, commandMembers,
@ -291,7 +288,7 @@ ${deviceCommandAssignments}
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
appendDispatchLoaderDynamicCommands( extIt.second->second.commands, appendDispatchLoaderDynamicCommands( extIt.second->second.requireData,
listedCommands, listedCommands,
extIt.second->first, extIt.second->first,
commandMembers, commandMembers,
@ -323,12 +320,12 @@ ${commands}
std::set<std::string> listedCommands; std::set<std::string> listedCommands;
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
commands += generateDispatchLoaderStaticCommands( feature.second.commands, listedCommands, feature.first ); commands += generateDispatchLoaderStaticCommands( feature.second.requireData, listedCommands, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
commands += commands +=
generateDispatchLoaderStaticCommands( extIt.second->second.commands, listedCommands, extIt.second->first ); generateDispatchLoaderStaticCommands( extIt.second->second.requireData, listedCommands, extIt.second->first );
} }
return replaceWithMap( dispatchLoaderStaticTemplate, { { "commands", commands } } ); return replaceWithMap( dispatchLoaderStaticTemplate, { { "commands", commands } } );
@ -360,11 +357,11 @@ ${enums}
std::set<std::string> listedEnums; std::set<std::string> listedEnums;
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
enums += generateEnums( feature.second.types, listedEnums, feature.first ); enums += generateEnums( feature.second.requireData, listedEnums, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
enums += generateEnums( extIt.second->second.types, listedEnums, extIt.second->first ); enums += generateEnums( extIt.second->second.requireData, listedEnums, extIt.second->first );
} }
return replaceWithMap( enumsTemplate, { { "enums", enums } } ); return replaceWithMap( enumsTemplate, { { "enums", enums } } );
@ -422,11 +419,11 @@ ${hashes}
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
hashes += generateHashStructures( feature.second.types, feature.first ); hashes += generateHashStructures( feature.second.requireData, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
hashes += generateHashStructures( extIt.second->second.types, extIt.second->first ); hashes += generateHashStructures( extIt.second->second.requireData, extIt.second->first );
} }
return replaceWithMap( hashesTemplate, { { "hashes", hashes } } ); return replaceWithMap( hashesTemplate, { { "hashes", hashes } } );
} }
@ -517,12 +514,12 @@ ${commandDefinitions}
std::set<std::string> listedCommands; // some commands are listed with more than one extension! std::set<std::string> listedCommands; // some commands are listed with more than one extension!
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
commandDefinitions += generateRAIICommandDefinitions( feature.second.commands, listedCommands, feature.first ); commandDefinitions += generateRAIICommandDefinitions( feature.second.requireData, listedCommands, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
commandDefinitions += commandDefinitions +=
generateRAIICommandDefinitions( extIt.second->second.commands, listedCommands, extIt.second->first ); generateRAIICommandDefinitions( extIt.second->second.requireData, listedCommands, extIt.second->first );
} }
return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } ); return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } );
@ -722,11 +719,12 @@ ${structExtends}
std::set<std::string> listedStructs; std::set<std::string> listedStructs;
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
structExtends += generateStructExtendsStructs( feature.second.types, listedStructs, feature.first ); structExtends += generateStructExtendsStructs( feature.second.requireData, listedStructs, feature.first );
} }
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
structExtends += generateStructExtendsStructs( extIt.second->second.types, listedStructs, extIt.second->first ); structExtends +=
generateStructExtendsStructs( extIt.second->second.requireData, listedStructs, extIt.second->first );
} }
return replaceWithMap( structExtendsTemplate, { { "structExtends", structExtends } } ); return replaceWithMap( structExtendsTemplate, { { "structExtends", structExtends } } );
@ -847,10 +845,12 @@ void VulkanHppGenerator::addCommand( std::string const & name, CommandData & com
"command list of handle <" + handleIt->first + "> already holds a commnand <" + name + ">" ); "command list of handle <" + handleIt->first + "> already holds a commnand <" + name + ">" );
} }
void VulkanHppGenerator::addMissingFlagBits( std::vector<std::string> & types, std::string const & referencedIn ) void VulkanHppGenerator::addMissingFlagBits( std::vector<RequireData> & requireData, std::string const & referencedIn )
{ {
for ( auto & require : requireData )
{
std::vector<std::string> newTypes; std::vector<std::string> newTypes;
for ( auto & type : types ) for ( auto const & type : require.types )
{ {
auto bitmaskIt = m_bitmasks.find( type ); auto bitmaskIt = m_bitmasks.find( type );
if ( ( bitmaskIt != m_bitmasks.end() ) && bitmaskIt->second.requirements.empty() ) if ( ( bitmaskIt != m_bitmasks.end() ) && bitmaskIt->second.requirements.empty() )
@ -878,13 +878,15 @@ void VulkanHppGenerator::addMissingFlagBits( std::vector<std::string> & types, s
assert( m_types.find( flagBits ) != m_types.end() ); assert( m_types.find( flagBits ) != m_types.end() );
} }
assert( std::find_if( types.begin(), assert( std::find_if( require.types.begin(),
types.end(), require.types.end(),
[&flagBits]( std::string const & type ) { return ( type == flagBits ); } ) == types.end() ); [&flagBits]( std::string const & type )
{ return ( type == flagBits ); } ) == require.types.end() );
newTypes.push_back( flagBits ); newTypes.push_back( flagBits );
} }
} }
types.insert( types.end(), newTypes.begin(), newTypes.end() ); require.types.insert( require.types.end(), newTypes.begin(), newTypes.end() );
}
} }
std::string VulkanHppGenerator::addTitleAndProtection( std::string const & str, std::string const & title ) const std::string VulkanHppGenerator::addTitleAndProtection( std::string const & str, std::string const & title ) const
@ -898,7 +900,7 @@ std::string VulkanHppGenerator::addTitleAndProtection( std::string const & str,
return str; return str;
} }
void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<std::string> const & commands, void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title, std::string const & title,
std::string & commandMembers, std::string & commandMembers,
@ -907,7 +909,9 @@ void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<std::s
std::string & deviceCommandAssignments ) const std::string & deviceCommandAssignments ) const
{ {
std::string members, initial, instance, device; std::string members, initial, instance, device;
for ( auto const & command : commands ) for ( auto const & require : requireData )
{
for ( auto const & command : require.commands )
{ {
if ( listedCommands.find( command ) == listedCommands.end() ) if ( listedCommands.find( command ) == listedCommands.end() )
{ {
@ -931,6 +935,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<std::s
} }
} }
} }
}
std::string enter, leave; std::string enter, leave;
std::tie( enter, leave ) = generateProtection( title, std::string() ); std::tie( enter, leave ) = generateProtection( title, std::string() );
std::string header = "\n" + enter + " //=== " + title + " ===\n"; std::string header = "\n" + enter + " //=== " + title + " ===\n";
@ -1338,23 +1343,6 @@ std::string replaceWithMap( std::string const & input, std::map<std::string, std
return result; return result;
} }
std::vector<std::string> selectCommandsByHandle( std::vector<std::string> const & commands,
std::set<std::string> const & handleCommands,
std::set<std::string> & listedCommands )
{
std::vector<std::string> selectedCommands;
for ( auto const & command : commands )
{
if ( ( handleCommands.find( command ) != handleCommands.end() ) &&
( listedCommands.find( command ) == listedCommands.end() ) )
{
listedCommands.insert( command );
selectedCommands.push_back( command );
}
}
return selectedCommands;
}
std::string startLowerCase( std::string const & input ) std::string startLowerCase( std::string const & input )
{ {
return input.empty() ? "" : static_cast<char>( tolower( input[0] ) ) + input.substr( 1 ); return input.empty() ? "" : static_cast<char>( tolower( input[0] ) ) + input.substr( 1 );
@ -7238,7 +7226,9 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
{ {
std::vector<std::string> firstLevelCommands, secondLevelCommands; std::vector<std::string> firstLevelCommands, secondLevelCommands;
for ( auto const & command : feature.second.commands ) for ( auto const & require : feature.second.requireData )
{
for ( auto const & command : require.commands )
{ {
if ( specialFunctions.find( command ) == specialFunctions.end() ) if ( specialFunctions.find( command ) == specialFunctions.end() )
{ {
@ -7257,6 +7247,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
} }
} }
} }
}
if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() ) if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
{ {
functionDeclarations += "\n //=== " + feature.first + " ===\n"; functionDeclarations += "\n //=== " + feature.first + " ===\n";
@ -7276,7 +7267,9 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
std::vector<std::string> firstLevelCommands, secondLevelCommands; std::vector<std::string> firstLevelCommands, secondLevelCommands;
for ( auto const & command : extIt.second->second.commands ) for ( auto & req : extIt.second->second.requireData )
{
for ( auto const & command : req.commands )
{ {
if ( ( specialFunctions.find( command ) == specialFunctions.end() ) && if ( ( specialFunctions.find( command ) == specialFunctions.end() ) &&
( listedCommands.find( command ) == listedCommands.end() ) ) ( listedCommands.find( command ) == listedCommands.end() ) )
@ -7293,6 +7286,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
} }
} }
} }
}
if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() ) if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
{ {
std::string enter, leave; std::string enter, leave;
@ -9048,16 +9042,33 @@ void VulkanHppGenerator::checkCorrectness()
alias.second.xmlLine, alias.second.xmlLine,
"enum <" + alias.first + "> uses unknown alias <" + alias.second.name + ">" ); "enum <" + alias.first + "> uses unknown alias <" + alias.second.name + ">" );
} }
// check that any protection fits to the corresponding extension
for ( auto const & v : e.second.values )
{
if ( !v.protect.empty() )
{
auto extIt = m_extensions.find( v.extension );
assert( extIt != m_extensions.end() );
auto platformIt = m_platforms.find( extIt->second.platform );
assert( platformIt != m_platforms.end() );
check( v.protect == platformIt->second.protect,
v.xmlLine,
"attribute <protect> of enum value <" + v.name + "> is \"" + v.protect +
"\" but corresponding extension <" + v.extension + "> belongs to platform <" + platformIt->first +
"> with protection \"" + platformIt->second.protect + "\"" );
}
}
} }
// enum checks by features and extensions // enum checks by features and extensions
for ( auto & feature : m_features ) for ( auto & feature : m_features )
{ {
checkEnumCorrectness( feature.second.types ); checkEnumCorrectness( feature.second.requireData );
} }
for ( auto & ext : m_extensions ) for ( auto & ext : m_extensions )
{ {
checkEnumCorrectness( ext.second.types ); checkEnumCorrectness( ext.second.requireData );
} }
// extension checks // extension checks
@ -9084,11 +9095,12 @@ void VulkanHppGenerator::checkCorrectness()
extension.second.xmlLine, extension.second.xmlLine,
"extension promoted to unknown extension/version <" + extension.second.promotedTo + ">" ); "extension promoted to unknown extension/version <" + extension.second.promotedTo + ">" );
} }
for ( auto const & require : extension.second.requirements ) for ( auto const & require : extension.second.requireData )
{ {
check( m_extensions.find( require.first ) != m_extensions.end(), check( require.title.empty() || ( m_features.find( require.title ) != m_features.end() ) ||
require.second, ( m_extensions.find( require.title ) != m_extensions.end() ),
"extension <" + extension.first + "> lists an unknown require extension <" + require.first + ">" ); require.xmlLine,
"extension <" + extension.first + "> lists an unknown require <" + require.title + ">" );
} }
} }
@ -9268,9 +9280,11 @@ void VulkanHppGenerator::checkCorrectness()
assert( sTypeValues.empty() ); assert( sTypeValues.empty() );
} }
void VulkanHppGenerator::checkEnumCorrectness( std::vector<std::string> const & types ) const void VulkanHppGenerator::checkEnumCorrectness( std::vector<RequireData> const & requireData ) const
{ {
for ( auto const & type : types ) for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{ {
auto enumIt = m_enums.find( type ); auto enumIt = m_enums.find( type );
if ( ( enumIt != m_enums.end() ) && enumIt->second.isBitmask ) if ( ( enumIt != m_enums.end() ) && enumIt->second.isBitmask )
@ -9289,6 +9303,7 @@ void VulkanHppGenerator::checkEnumCorrectness( std::vector<std::string> const &
bitmaskIt->first + "> is not of type <VkFlags64>" ); bitmaskIt->first + "> is not of type <VkFlags64>" );
} }
} }
}
} }
bool VulkanHppGenerator::containsArray( std::string const & type ) const bool VulkanHppGenerator::containsArray( std::string const & type ) const
@ -9824,12 +9839,14 @@ std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskDa
return str; return str;
} }
std::string VulkanHppGenerator::generateBitmasks( std::vector<std::string> const & types, std::string VulkanHppGenerator::generateBitmasks( std::vector<RequireData> const & requireData,
std::set<std::string> & listedBitmasks, std::set<std::string> & listedBitmasks,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & type : types ) for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{ {
auto bitmaskIt = m_bitmasks.find( type ); auto bitmaskIt = m_bitmasks.find( type );
if ( ( bitmaskIt != m_bitmasks.end() ) && ( listedBitmasks.find( type ) == listedBitmasks.end() ) ) if ( ( bitmaskIt != m_bitmasks.end() ) && ( listedBitmasks.find( type ) == listedBitmasks.end() ) )
@ -9838,6 +9855,7 @@ std::string VulkanHppGenerator::generateBitmasks( std::vector<std::string> const
str += generateBitmask( bitmaskIt ); str += generateBitmask( bitmaskIt );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -9871,12 +9889,14 @@ std::string VulkanHppGenerator::generateCommand( std::string const & name,
return str; return str;
} }
std::string VulkanHppGenerator::generateCommandDefinitions( std::vector<std::string> const & commands, std::string VulkanHppGenerator::generateCommandDefinitions( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & command : commands ) for ( auto const & require : requireData )
{
for ( auto const & command : require.commands )
{ {
if ( listedCommands.find( command ) == listedCommands.end() ) if ( listedCommands.find( command ) == listedCommands.end() )
{ {
@ -9887,6 +9907,7 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::vector<std::str
str += generateCommandDefinitions( command, commandIt->second.handle ); str += generateCommandDefinitions( command, commandIt->second.handle );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -10971,12 +10992,14 @@ std::string VulkanHppGenerator::generateDispatchLoaderDynamicCommandAssignment(
return str; return str;
} }
std::string VulkanHppGenerator::generateDispatchLoaderStaticCommands( std::vector<std::string> const & commands, std::string VulkanHppGenerator::generateDispatchLoaderStaticCommands( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & command : commands ) for ( auto const & require : requireData )
{
for ( auto const & command : require.commands )
{ {
// some commands are listed for multiple extensions ! // some commands are listed for multiple extensions !
if ( listedCommands.find( command ) == listedCommands.end() ) if ( listedCommands.find( command ) == listedCommands.end() )
@ -11013,6 +11036,7 @@ std::string VulkanHppGenerator::generateDispatchLoaderStaticCommands( std::vecto
{ "returnType", commandIt->second.returnType } } ); { "returnType", commandIt->second.returnType } } );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -11154,12 +11178,14 @@ std::string VulkanHppGenerator::generateEnumInitializer( TypeInfo const &
return str; return str;
} }
std::string VulkanHppGenerator::generateEnums( std::vector<std::string> const & enums, std::string VulkanHppGenerator::generateEnums( std::vector<RequireData> const & requireData,
std::set<std::string> & listedEnums, std::set<std::string> & listedEnums,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & type : enums ) for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{ {
auto enumIt = m_enums.find( type ); auto enumIt = m_enums.find( type );
if ( ( enumIt != m_enums.end() ) && ( listedEnums.find( type ) == listedEnums.end() ) ) if ( ( enumIt != m_enums.end() ) && ( listedEnums.find( type ) == listedEnums.end() ) )
@ -11171,6 +11197,7 @@ std::string VulkanHppGenerator::generateEnums( std::vector<std::string> const &
str += generateEnumToString( *enumIt ); str += generateEnumToString( *enumIt );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -11583,7 +11610,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
std::vector<std::string> commands = std::vector<std::string> commands =
selectCommandsByHandle( feature.second.commands, handleData.second.commands, listedCommands ); selectCommandsByHandle( feature.second.requireData, handleData.second.commands, listedCommands );
if ( !commands.empty() ) if ( !commands.empty() )
{ {
str += "\n //=== " + feature.first + " ===\n"; str += "\n //=== " + feature.first + " ===\n";
@ -11612,8 +11639,8 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
#if !defined( NDEBUG ) #if !defined( NDEBUG )
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
assert( assert( selectCommandsByHandle( extIt.second->second.requireData, handleData.second.commands, listedCommands )
selectCommandsByHandle( extIt.second->second.commands, handleData.second.commands, listedCommands ).empty() ); .empty() );
} }
#endif #endif
} }
@ -11636,7 +11663,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
for ( auto const & feature : m_features ) for ( auto const & feature : m_features )
{ {
std::vector<std::string> commandNames = std::vector<std::string> commandNames =
selectCommandsByHandle( feature.second.commands, handleData.second.commands, listedCommands ); selectCommandsByHandle( feature.second.requireData, handleData.second.commands, listedCommands );
if ( !commandNames.empty() ) if ( !commandNames.empty() )
{ {
commands += "\n //=== " + feature.first + " ===\n"; commands += "\n //=== " + feature.first + " ===\n";
@ -11654,7 +11681,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
for ( auto const & extIt : m_extensionsByNumber ) for ( auto const & extIt : m_extensionsByNumber )
{ {
std::vector<std::string> commandNames = std::vector<std::string> commandNames =
selectCommandsByHandle( extIt.second->second.commands, handleData.second.commands, listedCommands ); selectCommandsByHandle( extIt.second->second.requireData, handleData.second.commands, listedCommands );
if ( !commandNames.empty() ) if ( !commandNames.empty() )
{ {
std::string enter, leave; std::string enter, leave;
@ -11824,7 +11851,7 @@ ${usingAlias}${leave})";
return str; return str;
} }
std::string VulkanHppGenerator::generateHashStructures( std::vector<std::string> const & types, std::string VulkanHppGenerator::generateHashStructures( std::vector<RequireData> const & requireData,
std::string const & title ) const std::string const & title ) const
{ {
const std::string hashTemplate = R"( const std::string hashTemplate = R"(
@ -11838,7 +11865,9 @@ std::string VulkanHppGenerator::generateHashStructures( std::vector<std::string>
)"; )";
std::string str; std::string str;
for ( auto const & type : types ) for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{ {
auto handleIt = m_handles.find( type ); auto handleIt = m_handles.find( type );
if ( handleIt != m_handles.end() ) if ( handleIt != m_handles.end() )
@ -11848,6 +11877,7 @@ std::string VulkanHppGenerator::generateHashStructures( std::vector<std::string>
str += replaceWithMap( hashTemplate, { { "name", handleName }, { "type", handleType } } ); str += replaceWithMap( hashTemplate, { { "name", handleName }, { "type", handleType } } );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -11906,7 +11936,6 @@ std::pair<std::string, std::string> VulkanHppGenerator::generateProtection( std:
{ {
if ( !referencedIn.empty() ) if ( !referencedIn.empty() )
{ {
assert( protect.empty() );
if ( m_features.find( referencedIn ) == m_features.end() ) if ( m_features.find( referencedIn ) == m_features.end() )
{ {
auto extensionIt = m_extensions.find( referencedIn ); auto extensionIt = m_extensions.find( referencedIn );
@ -11945,12 +11974,14 @@ std::pair<std::string, std::string> VulkanHppGenerator::generateProtection( std:
} }
} }
std::string VulkanHppGenerator::generateRAIICommandDefinitions( std::vector<std::string> const & commands, std::string VulkanHppGenerator::generateRAIICommandDefinitions( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & command : commands ) for ( auto const & require : requireData )
{
for ( auto const & command : require.commands )
{ {
if ( listedCommands.find( command ) == listedCommands.end() ) if ( listedCommands.find( command ) == listedCommands.end() )
{ {
@ -11959,6 +11990,7 @@ std::string VulkanHppGenerator::generateRAIICommandDefinitions( std::vector<std:
command, determineInitialSkipCount( command ), m_RAIISpecialFunctions, true ); command, determineInitialSkipCount( command ), m_RAIISpecialFunctions, true );
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
@ -12031,12 +12063,14 @@ std::string
return sizeCheck; return sizeCheck;
} }
std::string VulkanHppGenerator::generateStructExtendsStructs( std::vector<std::string> const & types, std::string VulkanHppGenerator::generateStructExtendsStructs( std::vector<RequireData> const & requireData,
std::set<std::string> & listedStructs, std::set<std::string> & listedStructs,
std::string const & title ) const std::string const & title ) const
{ {
std::string str; std::string str;
for ( auto const & type : types ) for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{ {
auto structIt = m_structures.find( type ); auto structIt = m_structures.find( type );
if ( structIt != m_structures.end() ) if ( structIt != m_structures.end() )
@ -12097,14 +12131,19 @@ std::string VulkanHppGenerator::generateStructExtendsStructs( std::vector<std::s
} }
} }
} }
}
return addTitleAndProtection( str, title ); return addTitleAndProtection( str, title );
} }
std::string VulkanHppGenerator::getPlatform( std::string const & extension ) const std::string VulkanHppGenerator::getPlatform( std::string const & title ) const
{ {
auto extensionIt = m_extensions.find( extension ); if ( m_features.find( title ) == m_features.end() )
{
auto extensionIt = m_extensions.find( title );
assert( extensionIt != m_extensions.end() ); assert( extensionIt != m_extensions.end() );
return extensionIt->second.platform; return extensionIt->second.platform;
}
return "";
} }
std::pair<std::string, std::string> VulkanHppGenerator::getPoolTypeAndName( std::string const & type ) const std::pair<std::string, std::string> VulkanHppGenerator::getPoolTypeAndName( std::string const & type ) const
@ -13008,7 +13047,7 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
check( pitb.second, line, "already encountered extension <" + name + ">" ); check( pitb.second, line, "already encountered extension <" + name + ">" );
for ( auto const & r : requirements ) for ( auto const & r : requirements )
{ {
check( pitb.first->second.requirements.insert( std::make_pair( r, line ) ).second, check( pitb.first->second.requiresAttribute.insert( r ).second,
line, line,
"required extension <" + r + "> already listed" ); "required extension <" + r + "> already listed" );
} }
@ -13144,30 +13183,40 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
std::vector<tinyxml2::XMLElement const *> children = getChildElements( element ); std::vector<tinyxml2::XMLElement const *> children = getChildElements( element );
checkElements( line, children, {}, { "command", "comment", "enum", "type" } ); checkElements( line, children, {}, { "command", "comment", "enum", "type" } );
std::map<std::string, ExtensionData>::iterator requireExtensionIt = m_extensions.end(); std::string requireTitle;
for ( auto const & attribute : attributes ) for ( auto const & attribute : attributes )
{ {
if ( attribute.first == "extension" ) if ( attribute.first == "extension" )
{ {
check( extensionIt->second.requirements.insert( std::make_pair( attribute.second, line ) ).second, assert( requireTitle.empty() );
requireTitle = attribute.second;
check( std::find_if( extensionIt->second.requireData.begin(),
extensionIt->second.requireData.end(),
[&requireTitle]( RequireData const & rd )
{ return rd.title == requireTitle; } ) == extensionIt->second.requireData.end(),
line, line,
"required extension <" + attribute.second + "> already listed" ); "required extension <" + requireTitle + "> already listed" );
requireExtensionIt = m_extensions.find( attribute.second );
} }
else else
{ {
assert( attribute.first == "feature" ); assert( attribute.first == "feature" );
check( check(
m_features.find( attribute.second ) != m_features.end(), line, "unknown feature <" + attribute.second + ">" ); m_features.find( attribute.second ) != m_features.end(), line, "unknown feature <" + attribute.second + ">" );
assert( requireTitle.empty() );
requireTitle = attribute.second;
} }
} }
RequireData requireData( line, requireTitle );
std::string extensionName = requireTitle.empty() ? extensionIt->first : requireTitle;
bool requireDataEmpty = true;
for ( auto child : children ) for ( auto child : children )
{ {
std::string value = child->Value(); std::string value = child->Value();
if ( value == "command" ) if ( value == "command" )
{ {
readExtensionRequireCommand( child, extensionIt ); readExtensionRequireCommand( child, extensionIt->first, requireData );
requireDataEmpty = false;
} }
else if ( value == "comment" ) else if ( value == "comment" )
{ {
@ -13175,17 +13224,23 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
} }
else if ( value == "enum" ) else if ( value == "enum" )
{ {
readRequireEnum( child, requireExtensionIt == m_extensions.end() ? extensionIt : requireExtensionIt ); readRequireEnum( child, extensionName );
} }
else if ( value == "type" ) else if ( value == "type" )
{ {
readExtensionRequireType( child, extensionIt ); readExtensionRequireType( child, extensionName, requireData );
requireDataEmpty = false;
} }
} }
if ( !requireDataEmpty )
{
extensionIt->second.requireData.push_back( requireData );
}
} }
void VulkanHppGenerator::readExtensionRequireCommand( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readExtensionRequireCommand( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt ) std::string const & extensionName,
RequireData & requireData )
{ {
int line = element->GetLineNum(); int line = element->GetLineNum();
std::map<std::string, std::string> attributes = getAttributes( element ); std::map<std::string, std::string> attributes = getAttributes( element );
@ -13206,30 +13261,27 @@ void VulkanHppGenerator::readExtensionRequireCommand( tinyxml2::XMLElement const
auto commandIt = m_commands.find( name ); auto commandIt = m_commands.find( name );
check( commandIt != m_commands.end(), check( commandIt != m_commands.end(),
line, line,
"command <" + name + "> marked as required in extension <" + extensionIt->first + "command <" + name + "> marked as required in extension <" + extensionName +
"> was not listed before as a command!" ); "> was not listed before as a command!" );
if ( commandIt->second.referencedIn.empty() ) if ( commandIt->second.referencedIn.empty() )
{ {
commandIt->second.referencedIn = extensionIt->first; commandIt->second.referencedIn = extensionName;
} }
else else
{ {
check( getPlatform( commandIt->second.referencedIn ) == getPlatform( extensionIt->first ), check( getPlatform( commandIt->second.referencedIn ) == getPlatform( extensionName ),
line, line,
"command <" + name + "> is referenced in extensions <" + commandIt->second.referencedIn + "> and <" + "command <" + name + "> is referenced in extensions <" + commandIt->second.referencedIn + "> and <" +
extensionIt->first + "> and thus protected by different platforms <" + extensionName + "> and thus protected by different platforms <" +
getPlatform( commandIt->second.referencedIn ) + "> and <" + getPlatform( extensionIt->first ) + ">!" ); getPlatform( commandIt->second.referencedIn ) + "> and <" + getPlatform( extensionName ) + ">!" );
}
if ( std::find( extensionIt->second.commands.begin(), extensionIt->second.commands.end(), name ) ==
extensionIt->second.commands.end() )
{
// some commands are listed more than once under different additional requirements
extensionIt->second.commands.push_back( name );
} }
assert( std::find( requireData.commands.begin(), requireData.commands.end(), name ) == requireData.commands.end() );
requireData.commands.push_back( name );
} }
void VulkanHppGenerator::readExtensionRequireType( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readExtensionRequireType( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt ) std::string const & extensionName,
RequireData & requireData )
{ {
int line = element->GetLineNum(); int line = element->GetLineNum();
std::map<std::string, std::string> attributes = getAttributes( element ); std::map<std::string, std::string> attributes = getAttributes( element );
@ -13250,18 +13302,17 @@ void VulkanHppGenerator::readExtensionRequireType( tinyxml2::XMLElement const *
check( typeIt != m_types.end(), line, "failed to find required type <" + name + ">" ); check( typeIt != m_types.end(), line, "failed to find required type <" + name + ">" );
if ( typeIt->second.referencedIn.empty() ) if ( typeIt->second.referencedIn.empty() )
{ {
typeIt->second.referencedIn = extensionIt->first; typeIt->second.referencedIn = extensionName;
assert( std::find( extensionIt->second.types.begin(), extensionIt->second.types.end(), name ) == assert( std::find( requireData.types.begin(), requireData.types.end(), name ) == requireData.types.end() );
extensionIt->second.types.end() ); requireData.types.push_back( name );
extensionIt->second.types.push_back( name );
} }
else else
{ {
check( getPlatform( typeIt->second.referencedIn ) == getPlatform( extensionIt->first ), check( getPlatform( typeIt->second.referencedIn ) == getPlatform( extensionName ),
line, line,
"type <" + name + "> is referenced in extensions <" + typeIt->second.referencedIn + "> and <" + "type <" + name + "> is referenced in extensions <" + typeIt->second.referencedIn + "> and <" +
extensionIt->first + "> and thus protected by different platforms <" + extensionName + "> and thus protected by different platforms <" +
getPlatform( typeIt->second.referencedIn ) + "> and <" + getPlatform( extensionIt->first ) + ">!" ); getPlatform( typeIt->second.referencedIn ) + "> and <" + getPlatform( extensionName ) + ">!" );
} }
} }
@ -13320,12 +13371,15 @@ void VulkanHppGenerator::readFeatureRequire( tinyxml2::XMLElement const *
std::vector<tinyxml2::XMLElement const *> children = getChildElements( element ); std::vector<tinyxml2::XMLElement const *> children = getChildElements( element );
checkElements( line, children, {}, { "command", "comment", "enum", "type" } ); checkElements( line, children, {}, { "command", "comment", "enum", "type" } );
RequireData requireData( line, "" );
bool requireDataEmpty = true;
for ( auto child : children ) for ( auto child : children )
{ {
std::string value = child->Value(); std::string value = child->Value();
if ( value == "command" ) if ( value == "command" )
{ {
readFeatureRequireCommand( child, featureIt ); readFeatureRequireCommand( child, featureIt, requireData );
requireDataEmpty = false;
} }
else if ( value == "comment" ) else if ( value == "comment" )
{ {
@ -13333,17 +13387,23 @@ void VulkanHppGenerator::readFeatureRequire( tinyxml2::XMLElement const *
} }
else if ( value == "enum" ) else if ( value == "enum" )
{ {
readRequireEnum( child, m_extensions.end() ); readRequireEnum( child, "" );
} }
else if ( value == "type" ) else if ( value == "type" )
{ {
readFeatureRequireType( child, featureIt ); readFeatureRequireType( child, featureIt, requireData );
requireDataEmpty = false;
} }
} }
if ( !requireDataEmpty )
{
featureIt->second.requireData.push_back( requireData );
}
} }
void VulkanHppGenerator::readFeatureRequireCommand( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readFeatureRequireCommand( tinyxml2::XMLElement const * element,
std::map<std::string, FeatureData>::iterator featureIt ) std::map<std::string, FeatureData>::iterator featureIt,
RequireData & requireData )
{ {
int line = element->GetLineNum(); int line = element->GetLineNum();
std::map<std::string, std::string> attributes = getAttributes( element ); std::map<std::string, std::string> attributes = getAttributes( element );
@ -13355,13 +13415,13 @@ void VulkanHppGenerator::readFeatureRequireCommand( tinyxml2::XMLElement const *
line, line,
"command <" + name + "> already listed with feature <" + commandIt->second.referencedIn + ">" ); "command <" + name + "> already listed with feature <" + commandIt->second.referencedIn + ">" );
commandIt->second.referencedIn = featureIt->first; commandIt->second.referencedIn = featureIt->first;
assert( std::find( featureIt->second.commands.begin(), featureIt->second.commands.end(), name ) == assert( std::find( requireData.commands.begin(), requireData.commands.end(), name ) == requireData.commands.end() );
featureIt->second.commands.end() ); requireData.commands.push_back( name );
featureIt->second.commands.push_back( name );
} }
void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const * element,
std::map<std::string, FeatureData>::iterator featureIt ) std::map<std::string, FeatureData>::iterator featureIt,
RequireData & requireData )
{ {
int line = element->GetLineNum(); int line = element->GetLineNum();
std::map<std::string, std::string> attributes = getAttributes( element ); std::map<std::string, std::string> attributes = getAttributes( element );
@ -13369,10 +13429,9 @@ void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const *
checkElements( line, getChildElements( element ), {} ); checkElements( line, getChildElements( element ), {} );
std::string name = attributes.find( "name" )->second; std::string name = attributes.find( "name" )->second;
auto featureTypeIt = std::find_if( featureIt->second.types.begin(), auto requireTypeIt = std::find_if(
featureIt->second.types.end(), requireData.types.begin(), requireData.types.end(), [&name]( std::string const & type ) { return type == name; } );
[&name]( std::string const & type ) { return type == name; } ); check( requireTypeIt == requireData.types.end(), line, "type <" + name + "> already listed for this feature!" );
check( featureTypeIt == featureIt->second.types.end(), line, "type <" + name + "> already listed for this feature!" );
// some types are in fact includes (like vk_platform) or defines (like VK_API_VERSION) // some types are in fact includes (like vk_platform) or defines (like VK_API_VERSION)
if ( ( m_defines.find( name ) == m_defines.end() ) && ( m_includes.find( name ) == m_includes.end() ) ) if ( ( m_defines.find( name ) == m_defines.end() ) && ( m_includes.find( name ) == m_includes.end() ) )
@ -13384,7 +13443,7 @@ void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const *
"type <" + name + "> already listed on feature <" + typeIt->second.referencedIn + ">" ); "type <" + name + "> already listed on feature <" + typeIt->second.referencedIn + ">" );
typeIt->second.referencedIn = featureIt->first; typeIt->second.referencedIn = featureIt->first;
featureIt->second.types.push_back( name ); requireData.types.push_back( name );
} }
} }
@ -13639,8 +13698,7 @@ void VulkanHppGenerator::readRegistry( tinyxml2::XMLElement const * element )
} }
} }
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extensionName )
std::map<std::string, ExtensionData>::iterator extensionIt )
{ {
std::map<std::string, std::string> attributes = getAttributes( element ); std::map<std::string, std::string> attributes = getAttributes( element );
if ( attributes.find( "alias" ) != attributes.end() ) if ( attributes.find( "alias" ) != attributes.end() )
@ -13649,13 +13707,13 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
} }
else else
{ {
readRequireEnum( element, attributes, extensionIt ); readRequireEnum( element, attributes, extensionName );
} }
} }
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes, std::map<std::string, std::string> const & attributes,
std::map<std::string, ExtensionData>::iterator extensionIt ) std::string const & extensionName )
{ {
int line = element->GetLineNum(); int line = element->GetLineNum();
checkAttributes( line, checkAttributes( line,
@ -13671,7 +13729,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
{ "value", {} } } ); { "value", {} } } );
checkElements( line, getChildElements( element ), {} ); checkElements( line, getChildElements( element ), {} );
std::string bitpos, name, extends, extnumber, offset, value; std::string bitpos, name, extends, extnumber, offset, protect, value;
for ( auto const & attribute : attributes ) for ( auto const & attribute : attributes )
{ {
if ( attribute.first == "bitpos" ) if ( attribute.first == "bitpos" )
@ -13692,14 +13750,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
} }
else if ( attribute.first == "protect" ) else if ( attribute.first == "protect" )
{ {
// for now, attribute "protect" is, if set at all, set to "VK_ENABLE_BETA_EXTENSIONS" protect = attribute.second;
// and it's redundant with the platform set for this extension!
assert( extensionIt != m_extensions.end() );
check(
extensionIt->second.platform == "provisional",
line,
"attribute <protect> is \"VK_ENABLE_BETA_EXTENSIONS\", but the extensions platform is not \"provisional\" but \"" +
extensionIt->second.platform + "\"" );
} }
else if ( attribute.first == "value" ) else if ( attribute.first == "value" )
{ {
@ -13717,11 +13768,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
line, line,
"exactly one out of bitpos = <" + bitpos + ">, offset = <" + offset + ">, and value = <" + value + "exactly one out of bitpos = <" + bitpos + ">, offset = <" + offset + ">, and value = <" + value +
"> are supposed to be empty" ); "> are supposed to be empty" );
enumIt->second.addEnumValue( element->GetLineNum(), enumIt->second.addEnumValue( element->GetLineNum(), name, protect, !bitpos.empty(), extensionName );
name,
"",
!bitpos.empty(),
( extensionIt != m_extensions.end() ) ? extensionIt->first : "" );
} }
else if ( value.empty() ) else if ( value.empty() )
{ {
@ -14641,6 +14688,26 @@ void VulkanHppGenerator::rescheduleRAIIHandle( std::string &
} }
} }
std::vector<std::string> VulkanHppGenerator::selectCommandsByHandle( std::vector<RequireData> const & requireData,
std::set<std::string> const & handleCommands,
std::set<std::string> & listedCommands ) const
{
std::vector<std::string> selectedCommands;
for ( auto const & require : requireData )
{
for ( auto const & command : require.commands )
{
if ( ( handleCommands.find( command ) != handleCommands.end() ) &&
( listedCommands.find( command ) == listedCommands.end() ) )
{
listedCommands.insert( command );
selectedCommands.push_back( command );
}
}
}
return selectedCommands;
}
void VulkanHppGenerator::setVulkanLicenseHeader( int line, std::string const & comment ) void VulkanHppGenerator::setVulkanLicenseHeader( int line, std::string const & comment )
{ {
check( m_vulkanLicenseHeader.empty(), line, "second encounter of a Copyright comment" ); check( m_vulkanLicenseHeader.empty(), line, "second encounter of a Copyright comment" );

60
VulkanHppGenerator.hpp
View File

@ -171,13 +171,22 @@ private:
int xmlLine; int xmlLine;
}; };
struct RequireData
{
RequireData( int line, std::string const & title_ ) : title( title_ ), xmlLine( line ) {}
std::string title;
std::vector<std::string> commands;
std::vector<std::string> types;
int xmlLine;
};
struct FeatureData struct FeatureData
{ {
FeatureData( std::string const & number_ ) : number( number_ ) {} FeatureData( std::string const & number_ ) : number( number_ ) {}
std::vector<std::string> commands;
std::string number; std::string number;
std::vector<std::string> types; std::vector<RequireData> requireData;
}; };
struct ExtensionData struct ExtensionData
@ -196,14 +205,13 @@ private:
, xmlLine( line ) , xmlLine( line )
{} {}
std::vector<std::string> commands;
std::string deprecatedBy; std::string deprecatedBy;
std::string number; std::string number;
std::string obsoletedBy; std::string obsoletedBy;
std::string platform; std::string platform;
std::string promotedTo; std::string promotedTo;
std::map<std::string, int> requirements; std::set<std::string> requiresAttribute;
std::vector<std::string> types; std::vector<RequireData> requireData;
int xmlLine; int xmlLine;
}; };
@ -308,9 +316,9 @@ private:
private: private:
void addCommand( std::string const & name, CommandData & commandData ); void addCommand( std::string const & name, CommandData & commandData );
void addMissingFlagBits( std::vector<std::string> & types, std::string const & referencedIn ); void addMissingFlagBits( std::vector<RequireData> & requireData, std::string const & referencedIn );
std::string addTitleAndProtection( std::string const & str, std::string const & title ) const; std::string addTitleAndProtection( std::string const & str, std::string const & title ) const;
void appendDispatchLoaderDynamicCommands( std::vector<std::string> const & commands, void appendDispatchLoaderDynamicCommands( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title, std::string const & title,
std::string & commandMembers, std::string & commandMembers,
@ -844,7 +852,7 @@ private:
std::map<size_t, std::vector<size_t>> const & countToVectorMap, std::map<size_t, std::vector<size_t>> const & countToVectorMap,
std::set<size_t> const & skippedParams ) const; std::set<size_t> const & skippedParams ) const;
void checkCorrectness(); void checkCorrectness();
void checkEnumCorrectness( std::vector<std::string> const & types ) const; void checkEnumCorrectness( std::vector<RequireData> const & requireData ) const;
bool containsArray( std::string const & type ) const; bool containsArray( std::string const & type ) const;
bool containsUnion( std::string const & type ) const; bool containsUnion( std::string const & type ) const;
size_t determineDefaultStartIndex( std::vector<ParamData> const & params, size_t determineDefaultStartIndex( std::vector<ParamData> const & params,
@ -874,14 +882,14 @@ private:
void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions ); void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const; std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const;
std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const; std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
std::string generateBitmasks( std::vector<std::string> const & types, std::string generateBitmasks( std::vector<RequireData> const & requireData,
std::set<std::string> & listedBitmasks, std::set<std::string> & listedBitmasks,
std::string const & title ) const; std::string const & title ) const;
std::string generateCommand( std::string const & name, std::string generateCommand( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition ) const; bool definition ) const;
std::string generateCommandDefinitions( std::vector<std::string> const & commands, std::string generateCommandDefinitions( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const; std::string const & title ) const;
std::string generateCommandDefinitions( std::string const & command, std::string const & handle ) const; std::string generateCommandDefinitions( std::string const & command, std::string const & handle ) const;
@ -1016,7 +1024,7 @@ private:
std::string generateDispatchLoaderDynamicCommandAssignment( std::string const & commandName, std::string generateDispatchLoaderDynamicCommandAssignment( std::string const & commandName,
CommandData const & commandData, CommandData const & commandData,
std::string const & firstArg ) const; std::string const & firstArg ) const;
std::string generateDispatchLoaderStaticCommands( std::vector<std::string> const & commands, std::string generateDispatchLoaderStaticCommands( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const; std::string const & title ) const;
std::string generateEnum( std::pair<std::string, EnumData> const & enumData ) const; std::string generateEnum( std::pair<std::string, EnumData> const & enumData ) const;
@ -1024,7 +1032,7 @@ private:
std::vector<std::string> const & arraySizes, std::vector<std::string> const & arraySizes,
std::vector<EnumValueData> const & values, std::vector<EnumValueData> const & values,
bool bitmask ) const; bool bitmask ) const;
std::string generateEnums( std::vector<std::string> const & enums, std::string generateEnums( std::vector<RequireData> const & requireData,
std::set<std::string> & listedEnums, std::set<std::string> & listedEnums,
std::string const & title ) const; std::string const & title ) const;
std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const; std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const;
@ -1068,7 +1076,7 @@ private:
bool isTemplateParam ) const; bool isTemplateParam ) const;
std::string generateHandle( std::pair<std::string, HandleData> const & handle, std::string generateHandle( std::pair<std::string, HandleData> const & handle,
std::set<std::string> & listedHandles ) const; std::set<std::string> & listedHandles ) const;
std::string generateHashStructures( std::vector<std::string> const & types, std::string const & title ) const; std::string generateHashStructures( std::vector<RequireData> const & requireData, std::string const & title ) const;
std::string std::string
generateLenInitializer( std::vector<MemberData>::const_iterator mit, generateLenInitializer( std::vector<MemberData>::const_iterator mit,
std::map<std::vector<MemberData>::const_iterator, std::map<std::vector<MemberData>::const_iterator,
@ -1077,17 +1085,17 @@ private:
std::pair<std::string, std::string> generateProtection( std::string const & referencedIn, std::pair<std::string, std::string> generateProtection( std::string const & referencedIn,
std::string const & protect ) const; std::string const & protect ) const;
std::pair<std::string, std::string> generateProtection( std::string const & type, bool isAliased ) const; std::pair<std::string, std::string> generateProtection( std::string const & type, bool isAliased ) const;
std::string generateRAIICommandDefinitions( std::vector<std::string> const & commands, std::string generateRAIICommandDefinitions( std::vector<RequireData> const & requireData,
std::set<std::string> & listedCommands, std::set<std::string> & listedCommands,
std::string const & title ) const; std::string const & title ) const;
std::string generateSizeCheck( std::vector<std::vector<MemberData>::const_iterator> const & arrayIts, std::string generateSizeCheck( std::vector<std::vector<MemberData>::const_iterator> const & arrayIts,
std::string const & structName, std::string const & structName,
std::string const & prefix, std::string const & prefix,
bool mutualExclusiveLens ) const; bool mutualExclusiveLens ) const;
std::string generateStructExtendsStructs( std::vector<std::string> const & types, std::string generateStructExtendsStructs( std::vector<RequireData> const & requireData,
std::set<std::string> & listedStructs, std::set<std::string> & listedStructs,
std::string const & title ) const; std::string const & title ) const;
std::string getPlatform( std::string const & extension ) const; std::string getPlatform( std::string const & title ) const;
std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const; std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
std::string getVectorSize( std::vector<ParamData> const & params, std::string getVectorSize( std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
@ -1130,28 +1138,31 @@ private:
void readExtensionRequire( tinyxml2::XMLElement const * element, void readExtensionRequire( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt ); std::map<std::string, ExtensionData>::iterator extensionIt );
void readExtensionRequireCommand( tinyxml2::XMLElement const * element, void readExtensionRequireCommand( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt ); std::string const & extensionName,
RequireData & requireData );
void readExtensionRequireType( tinyxml2::XMLElement const * element, void readExtensionRequireType( tinyxml2::XMLElement const * element,
std::map<std::string, ExtensionData>::iterator extensionIt ); std::string const & extensionName,
RequireData & requireData );
void readExtensions( tinyxml2::XMLElement const * element ); void readExtensions( tinyxml2::XMLElement const * element );
void readFeature( tinyxml2::XMLElement const * element ); void readFeature( tinyxml2::XMLElement const * element );
void readFeatureRequire( tinyxml2::XMLElement const * element, void readFeatureRequire( tinyxml2::XMLElement const * element,
std::map<std::string, FeatureData>::iterator featureIt ); std::map<std::string, FeatureData>::iterator featureIt );
void readFeatureRequireCommand( tinyxml2::XMLElement const * element, void readFeatureRequireCommand( tinyxml2::XMLElement const * element,
std::map<std::string, FeatureData>::iterator featureIt ); std::map<std::string, FeatureData>::iterator featureIt,
RequireData & requireData );
void readFeatureRequireType( tinyxml2::XMLElement const * element, void readFeatureRequireType( tinyxml2::XMLElement const * element,
std::map<std::string, FeatureData>::iterator featureIt ); std::map<std::string, FeatureData>::iterator featureIt,
RequireData & requireData );
void readFuncpointer( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes ); void readFuncpointer( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
void readHandle( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes ); void readHandle( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
std::pair<NameData, TypeInfo> readNameAndType( tinyxml2::XMLElement const * elements ); std::pair<NameData, TypeInfo> readNameAndType( tinyxml2::XMLElement const * elements );
void readPlatform( tinyxml2::XMLElement const * element ); void readPlatform( tinyxml2::XMLElement const * element );
void readPlatforms( tinyxml2::XMLElement const * element ); void readPlatforms( tinyxml2::XMLElement const * element );
void readRegistry( tinyxml2::XMLElement const * element ); void readRegistry( tinyxml2::XMLElement const * element );
void readRequireEnum( tinyxml2::XMLElement const * element, void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extensionName );
std::map<std::string, ExtensionData>::iterator extensionIt );
void readRequireEnum( tinyxml2::XMLElement const * element, void readRequireEnum( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes, std::map<std::string, std::string> const & attributes,
std::map<std::string, ExtensionData>::iterator extensionIt ); std::string const & extensionName );
void readRequireEnumAlias( tinyxml2::XMLElement const * element, void readRequireEnumAlias( tinyxml2::XMLElement const * element,
std::map<std::string, std::string> const & attributes ); std::map<std::string, std::string> const & attributes );
void readRequires( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes ); void readRequires( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
@ -1188,6 +1199,9 @@ private:
std::pair<std::string, HandleData> const & handle, std::pair<std::string, HandleData> const & handle,
std::set<std::string> & listedHandles, std::set<std::string> & listedHandles,
std::set<std::string> const & specialFunctions ) const; std::set<std::string> const & specialFunctions ) const;
std::vector<std::string> selectCommandsByHandle( std::vector<RequireData> const & requireData,
std::set<std::string> const & handleCommands,
std::set<std::string> & listedCommands ) const;
void setVulkanLicenseHeader( int line, std::string const & comment ); void setVulkanLicenseHeader( int line, std::string const & comment );
std::string toString( TypeCategory category ); std::string toString( TypeCategory category );

342
vulkan/vulkan_enums.hpp
View File

@ -2835,6 +2835,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class InstanceCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
{
return "(void)";
}
enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
{ {
eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
@ -2849,6 +2858,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class DeviceCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
{
return "(void)";
}
enum class PipelineStageFlagBits : VkPipelineStageFlags enum class PipelineStageFlagBits : VkPipelineStageFlags
{ {
eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
@ -2918,6 +2936,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class MemoryMapFlagBits : VkMemoryMapFlags
{
};
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
{
return "(void)";
}
enum class ImageAspectFlagBits : VkImageAspectFlags enum class ImageAspectFlagBits : VkImageAspectFlags
{ {
eColor = VK_IMAGE_ASPECT_COLOR_BIT, eColor = VK_IMAGE_ASPECT_COLOR_BIT,
@ -3001,6 +3028,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
{
return "(void)";
}
enum class EventCreateFlagBits : VkEventCreateFlags enum class EventCreateFlagBits : VkEventCreateFlags
{ {
eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR
@ -3119,6 +3155,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class QueryPoolCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
{
return "(void)";
}
enum class BufferCreateFlagBits : VkBufferCreateFlags enum class BufferCreateFlagBits : VkBufferCreateFlags
{ {
eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
@ -3223,6 +3268,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
{
return "(void)";
}
enum class ImageLayout enum class ImageLayout
{ {
eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
@ -3996,6 +4050,96 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
{
return "(void)";
}
enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
{
return "(void)";
}
enum class BorderColor enum class BorderColor
{ {
eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
@ -4178,6 +4322,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags
{
};
VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
{
return "(void)";
}
enum class AccessFlagBits : VkAccessFlags enum class AccessFlagBits : VkAccessFlags
{ {
eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
@ -4541,159 +4694,6 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class InstanceCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
{
return "(void)";
}
enum class DeviceCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
{
return "(void)";
}
enum class MemoryMapFlagBits : VkMemoryMapFlags
{
};
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
{
return "(void)";
}
enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
{
return "(void)";
}
enum class QueryPoolCreateFlagBits
{
};
VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
{
return "(void)";
}
enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
{
return "(void)";
}
enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
{
return "(void)";
}
enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
{
return "(void)";
}
enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
{
return "(void)";
}
enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags
{
};
VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
{
return "(void)";
}
//=== VK_VERSION_1_1 === //=== VK_VERSION_1_1 ===
enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags
@ -4766,6 +4766,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags
{
};
VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits )
{
return "(void)";
}
enum class PointClippingBehavior enum class PointClippingBehavior
{ {
eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
@ -4874,6 +4883,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
{
return "(void)";
}
enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags
{ {
eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
@ -5055,24 +5073,6 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags
{
};
VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits )
{
return "(void)";
}
enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags
{
};
VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
{
return "(void)";
}
//=== VK_VERSION_1_2 === //=== VK_VERSION_1_2 ===
enum class DriverId enum class DriverId