mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-09-20 05:52:16 +00:00
Gather commands and types per require-block in features and extensions
This commit is contained in:
asuessenbach
parent
710c052892
commit
4a3c6d024d
@ -50,9 +50,6 @@ template <typename ElementContainer>
|
||||
std::vector<tinyxml2::XMLElement const *> getChildElements( ElementContainer const * element );
|
||||
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::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 startUpperCase( std::string const & input );
|
||||
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
|
||||
for ( auto & feature : m_features )
|
||||
{
|
||||
addMissingFlagBits( feature.second.types, feature.first );
|
||||
addMissingFlagBits( feature.second.requireData, feature.first );
|
||||
}
|
||||
for ( auto & ext : m_extensions )
|
||||
{
|
||||
addMissingFlagBits( ext.second.types, ext.first );
|
||||
addMissingFlagBits( ext.second.requireData, ext.first );
|
||||
}
|
||||
|
||||
// determine the extensionsByNumber map
|
||||
@ -152,11 +149,11 @@ ${bitmasks}
|
||||
std::set<std::string> listedBitmasks;
|
||||
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 )
|
||||
{
|
||||
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 } } );
|
||||
@ -176,12 +173,12 @@ ${commandDefinitions}
|
||||
std::set<std::string> listedCommands; // some commands are listed with more than one extension!
|
||||
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 )
|
||||
{
|
||||
commandDefinitions +=
|
||||
generateCommandDefinitions( extIt.second->second.commands, listedCommands, extIt.second->first );
|
||||
generateCommandDefinitions( extIt.second->second.requireData, listedCommands, extIt.second->first );
|
||||
}
|
||||
|
||||
return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } );
|
||||
@ -281,7 +278,7 @@ ${deviceCommandAssignments}
|
||||
std::set<std::string> listedCommands; // some commands are listed with more than one extension!
|
||||
for ( auto const & feature : m_features )
|
||||
{
|
||||
appendDispatchLoaderDynamicCommands( feature.second.commands,
|
||||
appendDispatchLoaderDynamicCommands( feature.second.requireData,
|
||||
listedCommands,
|
||||
feature.first,
|
||||
commandMembers,
|
||||
@ -291,7 +288,7 @@ ${deviceCommandAssignments}
|
||||
}
|
||||
for ( auto const & extIt : m_extensionsByNumber )
|
||||
{
|
||||
appendDispatchLoaderDynamicCommands( extIt.second->second.commands,
|
||||
appendDispatchLoaderDynamicCommands( extIt.second->second.requireData,
|
||||
listedCommands,
|
||||
extIt.second->first,
|
||||
commandMembers,
|
||||
@ -323,12 +320,12 @@ ${commands}
|
||||
std::set<std::string> listedCommands;
|
||||
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 )
|
||||
{
|
||||
commands +=
|
||||
generateDispatchLoaderStaticCommands( extIt.second->second.commands, listedCommands, extIt.second->first );
|
||||
generateDispatchLoaderStaticCommands( extIt.second->second.requireData, listedCommands, extIt.second->first );
|
||||
}
|
||||
|
||||
return replaceWithMap( dispatchLoaderStaticTemplate, { { "commands", commands } } );
|
||||
@ -360,11 +357,11 @@ ${enums}
|
||||
std::set<std::string> listedEnums;
|
||||
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 )
|
||||
{
|
||||
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 } } );
|
||||
@ -422,11 +419,11 @@ ${hashes}
|
||||
|
||||
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 )
|
||||
{
|
||||
hashes += generateHashStructures( extIt.second->second.types, extIt.second->first );
|
||||
hashes += generateHashStructures( extIt.second->second.requireData, extIt.second->first );
|
||||
}
|
||||
return replaceWithMap( hashesTemplate, { { "hashes", hashes } } );
|
||||
}
|
||||
@ -517,12 +514,12 @@ ${commandDefinitions}
|
||||
std::set<std::string> listedCommands; // some commands are listed with more than one extension!
|
||||
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 )
|
||||
{
|
||||
commandDefinitions +=
|
||||
generateRAIICommandDefinitions( extIt.second->second.commands, listedCommands, extIt.second->first );
|
||||
generateRAIICommandDefinitions( extIt.second->second.requireData, listedCommands, extIt.second->first );
|
||||
}
|
||||
|
||||
return replaceWithMap( commandDefinitionsTemplate, { { "commandDefinitions", commandDefinitions } } );
|
||||
@ -722,11 +719,12 @@ ${structExtends}
|
||||
std::set<std::string> listedStructs;
|
||||
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 )
|
||||
{
|
||||
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 } } );
|
||||
@ -847,10 +845,12 @@ void VulkanHppGenerator::addCommand( std::string const & name, CommandData & com
|
||||
"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;
|
||||
for ( auto & type : types )
|
||||
for ( auto const & type : require.types )
|
||||
{
|
||||
auto bitmaskIt = m_bitmasks.find( type );
|
||||
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( std::find_if( types.begin(),
|
||||
types.end(),
|
||||
[&flagBits]( std::string const & type ) { return ( type == flagBits ); } ) == types.end() );
|
||||
assert( std::find_if( require.types.begin(),
|
||||
require.types.end(),
|
||||
[&flagBits]( std::string const & type )
|
||||
{ return ( type == flagBits ); } ) == require.types.end() );
|
||||
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
|
||||
@ -898,7 +900,7 @@ std::string VulkanHppGenerator::addTitleAndProtection( std::string const & 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::string const & title,
|
||||
std::string & commandMembers,
|
||||
@ -907,7 +909,9 @@ void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<std::s
|
||||
std::string & deviceCommandAssignments ) const
|
||||
{
|
||||
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() )
|
||||
{
|
||||
@ -931,6 +935,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamicCommands( std::vector<std::s
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::string enter, leave;
|
||||
std::tie( enter, leave ) = generateProtection( title, std::string() );
|
||||
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;
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
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;
|
||||
|
||||
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() )
|
||||
{
|
||||
@ -7257,6 +7247,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
|
||||
{
|
||||
functionDeclarations += "\n //=== " + feature.first + " ===\n";
|
||||
@ -7276,7 +7267,9 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
|
||||
for ( auto const & extIt : m_extensionsByNumber )
|
||||
{
|
||||
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() ) &&
|
||||
( listedCommands.find( command ) == listedCommands.end() ) )
|
||||
@ -7293,6 +7286,7 @@ std::string VulkanHppGenerator::constructRAIIHandleMemberFunctionDeclarations(
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !firstLevelCommands.empty() || !secondLevelCommands.empty() )
|
||||
{
|
||||
std::string enter, leave;
|
||||
@ -9048,16 +9042,33 @@ void VulkanHppGenerator::checkCorrectness()
|
||||
alias.second.xmlLine,
|
||||
"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
|
||||
for ( auto & feature : m_features )
|
||||
{
|
||||
checkEnumCorrectness( feature.second.types );
|
||||
checkEnumCorrectness( feature.second.requireData );
|
||||
}
|
||||
for ( auto & ext : m_extensions )
|
||||
{
|
||||
checkEnumCorrectness( ext.second.types );
|
||||
checkEnumCorrectness( ext.second.requireData );
|
||||
}
|
||||
|
||||
// extension checks
|
||||
@ -9084,11 +9095,12 @@ void VulkanHppGenerator::checkCorrectness()
|
||||
extension.second.xmlLine,
|
||||
"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(),
|
||||
require.second,
|
||||
"extension <" + extension.first + "> lists an unknown require extension <" + require.first + ">" );
|
||||
check( require.title.empty() || ( m_features.find( require.title ) != m_features.end() ) ||
|
||||
( m_extensions.find( require.title ) != m_extensions.end() ),
|
||||
require.xmlLine,
|
||||
"extension <" + extension.first + "> lists an unknown require <" + require.title + ">" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -9268,9 +9280,11 @@ void VulkanHppGenerator::checkCorrectness()
|
||||
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 );
|
||||
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>" );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool VulkanHppGenerator::containsArray( std::string const & type ) const
|
||||
@ -9824,12 +9839,14 @@ std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskDa
|
||||
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::string const & title ) const
|
||||
{
|
||||
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 );
|
||||
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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -9871,12 +9889,14 @@ std::string VulkanHppGenerator::generateCommand( std::string const & name,
|
||||
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::string const & title ) const
|
||||
{
|
||||
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() )
|
||||
{
|
||||
@ -9887,6 +9907,7 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::vector<std::str
|
||||
str += generateCommandDefinitions( command, commandIt->second.handle );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -10971,12 +10992,14 @@ std::string VulkanHppGenerator::generateDispatchLoaderDynamicCommandAssignment(
|
||||
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::string const & title ) const
|
||||
{
|
||||
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 !
|
||||
if ( listedCommands.find( command ) == listedCommands.end() )
|
||||
@ -11013,6 +11036,7 @@ std::string VulkanHppGenerator::generateDispatchLoaderStaticCommands( std::vecto
|
||||
{ "returnType", commandIt->second.returnType } } );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -11154,12 +11178,14 @@ std::string VulkanHppGenerator::generateEnumInitializer( TypeInfo const &
|
||||
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::string const & title ) const
|
||||
{
|
||||
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 );
|
||||
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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -11583,7 +11610,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
|
||||
for ( auto const & feature : m_features )
|
||||
{
|
||||
std::vector<std::string> commands =
|
||||
selectCommandsByHandle( feature.second.commands, handleData.second.commands, listedCommands );
|
||||
selectCommandsByHandle( feature.second.requireData, handleData.second.commands, listedCommands );
|
||||
if ( !commands.empty() )
|
||||
{
|
||||
str += "\n //=== " + feature.first + " ===\n";
|
||||
@ -11612,8 +11639,8 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
|
||||
#if !defined( NDEBUG )
|
||||
for ( auto const & extIt : m_extensionsByNumber )
|
||||
{
|
||||
assert(
|
||||
selectCommandsByHandle( extIt.second->second.commands, handleData.second.commands, listedCommands ).empty() );
|
||||
assert( selectCommandsByHandle( extIt.second->second.requireData, handleData.second.commands, listedCommands )
|
||||
.empty() );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -11636,7 +11663,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
|
||||
for ( auto const & feature : m_features )
|
||||
{
|
||||
std::vector<std::string> commandNames =
|
||||
selectCommandsByHandle( feature.second.commands, handleData.second.commands, listedCommands );
|
||||
selectCommandsByHandle( feature.second.requireData, handleData.second.commands, listedCommands );
|
||||
if ( !commandNames.empty() )
|
||||
{
|
||||
commands += "\n //=== " + feature.first + " ===\n";
|
||||
@ -11654,7 +11681,7 @@ std::string VulkanHppGenerator::generateHandle( std::pair<std::string, HandleDat
|
||||
for ( auto const & extIt : m_extensionsByNumber )
|
||||
{
|
||||
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() )
|
||||
{
|
||||
std::string enter, leave;
|
||||
@ -11824,7 +11851,7 @@ ${usingAlias}${leave})";
|
||||
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
|
||||
{
|
||||
const std::string hashTemplate = R"(
|
||||
@ -11838,7 +11865,9 @@ std::string VulkanHppGenerator::generateHashStructures( std::vector<std::string>
|
||||
)";
|
||||
|
||||
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 );
|
||||
if ( handleIt != m_handles.end() )
|
||||
@ -11848,6 +11877,7 @@ std::string VulkanHppGenerator::generateHashStructures( std::vector<std::string>
|
||||
str += replaceWithMap( hashTemplate, { { "name", handleName }, { "type", handleType } } );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -11906,7 +11936,6 @@ std::pair<std::string, std::string> VulkanHppGenerator::generateProtection( std:
|
||||
{
|
||||
if ( !referencedIn.empty() )
|
||||
{
|
||||
assert( protect.empty() );
|
||||
if ( m_features.find( referencedIn ) == m_features.end() )
|
||||
{
|
||||
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::string const & title ) const
|
||||
{
|
||||
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() )
|
||||
{
|
||||
@ -11959,6 +11990,7 @@ std::string VulkanHppGenerator::generateRAIICommandDefinitions( std::vector<std:
|
||||
command, determineInitialSkipCount( command ), m_RAIISpecialFunctions, true );
|
||||
}
|
||||
}
|
||||
}
|
||||
return addTitleAndProtection( str, title );
|
||||
}
|
||||
|
||||
@ -12031,12 +12063,14 @@ std::string
|
||||
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::string const & title ) const
|
||||
{
|
||||
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 );
|
||||
if ( structIt != m_structures.end() )
|
||||
@ -12097,14 +12131,19 @@ std::string VulkanHppGenerator::generateStructExtendsStructs( std::vector<std::s
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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() );
|
||||
return extensionIt->second.platform;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
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 + ">" );
|
||||
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,
|
||||
"required extension <" + r + "> already listed" );
|
||||
}
|
||||
@ -13144,30 +13183,40 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
|
||||
std::vector<tinyxml2::XMLElement const *> children = getChildElements( element );
|
||||
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 )
|
||||
{
|
||||
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,
|
||||
"required extension <" + attribute.second + "> already listed" );
|
||||
requireExtensionIt = m_extensions.find( attribute.second );
|
||||
"required extension <" + requireTitle + "> already listed" );
|
||||
}
|
||||
else
|
||||
{
|
||||
assert( attribute.first == "feature" );
|
||||
check(
|
||||
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 )
|
||||
{
|
||||
std::string value = child->Value();
|
||||
if ( value == "command" )
|
||||
{
|
||||
readExtensionRequireCommand( child, extensionIt );
|
||||
readExtensionRequireCommand( child, extensionIt->first, requireData );
|
||||
requireDataEmpty = false;
|
||||
}
|
||||
else if ( value == "comment" )
|
||||
{
|
||||
@ -13175,17 +13224,23 @@ void VulkanHppGenerator::readExtensionRequire( tinyxml2::XMLElement const *
|
||||
}
|
||||
else if ( value == "enum" )
|
||||
{
|
||||
readRequireEnum( child, requireExtensionIt == m_extensions.end() ? extensionIt : requireExtensionIt );
|
||||
readRequireEnum( child, extensionName );
|
||||
}
|
||||
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,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt )
|
||||
std::string const & extensionName,
|
||||
RequireData & requireData )
|
||||
{
|
||||
int line = element->GetLineNum();
|
||||
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 );
|
||||
check( commandIt != m_commands.end(),
|
||||
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!" );
|
||||
if ( commandIt->second.referencedIn.empty() )
|
||||
{
|
||||
commandIt->second.referencedIn = extensionIt->first;
|
||||
commandIt->second.referencedIn = extensionName;
|
||||
}
|
||||
else
|
||||
{
|
||||
check( getPlatform( commandIt->second.referencedIn ) == getPlatform( extensionIt->first ),
|
||||
check( getPlatform( commandIt->second.referencedIn ) == getPlatform( extensionName ),
|
||||
line,
|
||||
"command <" + name + "> is referenced in extensions <" + commandIt->second.referencedIn + "> and <" +
|
||||
extensionIt->first + "> and thus protected by different platforms <" +
|
||||
getPlatform( commandIt->second.referencedIn ) + "> and <" + getPlatform( extensionIt->first ) + ">!" );
|
||||
}
|
||||
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 );
|
||||
extensionName + "> and thus protected by different platforms <" +
|
||||
getPlatform( commandIt->second.referencedIn ) + "> and <" + getPlatform( extensionName ) + ">!" );
|
||||
}
|
||||
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,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt )
|
||||
std::string const & extensionName,
|
||||
RequireData & requireData )
|
||||
{
|
||||
int line = element->GetLineNum();
|
||||
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 + ">" );
|
||||
if ( typeIt->second.referencedIn.empty() )
|
||||
{
|
||||
typeIt->second.referencedIn = extensionIt->first;
|
||||
assert( std::find( extensionIt->second.types.begin(), extensionIt->second.types.end(), name ) ==
|
||||
extensionIt->second.types.end() );
|
||||
extensionIt->second.types.push_back( name );
|
||||
typeIt->second.referencedIn = extensionName;
|
||||
assert( std::find( requireData.types.begin(), requireData.types.end(), name ) == requireData.types.end() );
|
||||
requireData.types.push_back( name );
|
||||
}
|
||||
else
|
||||
{
|
||||
check( getPlatform( typeIt->second.referencedIn ) == getPlatform( extensionIt->first ),
|
||||
check( getPlatform( typeIt->second.referencedIn ) == getPlatform( extensionName ),
|
||||
line,
|
||||
"type <" + name + "> is referenced in extensions <" + typeIt->second.referencedIn + "> and <" +
|
||||
extensionIt->first + "> and thus protected by different platforms <" +
|
||||
getPlatform( typeIt->second.referencedIn ) + "> and <" + getPlatform( extensionIt->first ) + ">!" );
|
||||
extensionName + "> and thus protected by different platforms <" +
|
||||
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 );
|
||||
checkElements( line, children, {}, { "command", "comment", "enum", "type" } );
|
||||
|
||||
RequireData requireData( line, "" );
|
||||
bool requireDataEmpty = true;
|
||||
for ( auto child : children )
|
||||
{
|
||||
std::string value = child->Value();
|
||||
if ( value == "command" )
|
||||
{
|
||||
readFeatureRequireCommand( child, featureIt );
|
||||
readFeatureRequireCommand( child, featureIt, requireData );
|
||||
requireDataEmpty = false;
|
||||
}
|
||||
else if ( value == "comment" )
|
||||
{
|
||||
@ -13333,17 +13387,23 @@ void VulkanHppGenerator::readFeatureRequire( tinyxml2::XMLElement const *
|
||||
}
|
||||
else if ( value == "enum" )
|
||||
{
|
||||
readRequireEnum( child, m_extensions.end() );
|
||||
readRequireEnum( child, "" );
|
||||
}
|
||||
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,
|
||||
std::map<std::string, FeatureData>::iterator featureIt )
|
||||
std::map<std::string, FeatureData>::iterator featureIt,
|
||||
RequireData & requireData )
|
||||
{
|
||||
int line = element->GetLineNum();
|
||||
std::map<std::string, std::string> attributes = getAttributes( element );
|
||||
@ -13355,13 +13415,13 @@ void VulkanHppGenerator::readFeatureRequireCommand( tinyxml2::XMLElement const *
|
||||
line,
|
||||
"command <" + name + "> already listed with feature <" + commandIt->second.referencedIn + ">" );
|
||||
commandIt->second.referencedIn = featureIt->first;
|
||||
assert( std::find( featureIt->second.commands.begin(), featureIt->second.commands.end(), name ) ==
|
||||
featureIt->second.commands.end() );
|
||||
featureIt->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::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();
|
||||
std::map<std::string, std::string> attributes = getAttributes( element );
|
||||
@ -13369,10 +13429,9 @@ void VulkanHppGenerator::readFeatureRequireType( tinyxml2::XMLElement const *
|
||||
checkElements( line, getChildElements( element ), {} );
|
||||
|
||||
std::string name = attributes.find( "name" )->second;
|
||||
auto featureTypeIt = std::find_if( featureIt->second.types.begin(),
|
||||
featureIt->second.types.end(),
|
||||
[&name]( std::string const & type ) { return type == name; } );
|
||||
check( featureTypeIt == featureIt->second.types.end(), line, "type <" + name + "> already listed for this feature!" );
|
||||
auto requireTypeIt = std::find_if(
|
||||
requireData.types.begin(), requireData.types.end(), [&name]( std::string const & type ) { return type == name; } );
|
||||
check( requireTypeIt == requireData.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)
|
||||
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 + ">" );
|
||||
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,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt )
|
||||
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extensionName )
|
||||
{
|
||||
std::map<std::string, std::string> attributes = getAttributes( element );
|
||||
if ( attributes.find( "alias" ) != attributes.end() )
|
||||
@ -13649,13 +13707,13 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
|
||||
}
|
||||
else
|
||||
{
|
||||
readRequireEnum( element, attributes, extensionIt );
|
||||
readRequireEnum( element, attributes, extensionName );
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
|
||||
std::map<std::string, std::string> const & attributes,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt )
|
||||
std::string const & extensionName )
|
||||
{
|
||||
int line = element->GetLineNum();
|
||||
checkAttributes( line,
|
||||
@ -13671,7 +13729,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
|
||||
{ "value", {} } } );
|
||||
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 )
|
||||
{
|
||||
if ( attribute.first == "bitpos" )
|
||||
@ -13692,14 +13750,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
|
||||
}
|
||||
else if ( attribute.first == "protect" )
|
||||
{
|
||||
// for now, attribute "protect" is, if set at all, set to "VK_ENABLE_BETA_EXTENSIONS"
|
||||
// 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 + "\"" );
|
||||
protect = attribute.second;
|
||||
}
|
||||
else if ( attribute.first == "value" )
|
||||
{
|
||||
@ -13717,11 +13768,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const *
|
||||
line,
|
||||
"exactly one out of bitpos = <" + bitpos + ">, offset = <" + offset + ">, and value = <" + value +
|
||||
"> are supposed to be empty" );
|
||||
enumIt->second.addEnumValue( element->GetLineNum(),
|
||||
name,
|
||||
"",
|
||||
!bitpos.empty(),
|
||||
( extensionIt != m_extensions.end() ) ? extensionIt->first : "" );
|
||||
enumIt->second.addEnumValue( element->GetLineNum(), name, protect, !bitpos.empty(), extensionName );
|
||||
}
|
||||
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 )
|
||||
{
|
||||
check( m_vulkanLicenseHeader.empty(), line, "second encounter of a Copyright comment" );
|
||||
|
||||
@ -171,13 +171,22 @@ private:
|
||||
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
|
||||
{
|
||||
FeatureData( std::string const & number_ ) : number( number_ ) {}
|
||||
|
||||
std::vector<std::string> commands;
|
||||
std::string number;
|
||||
std::vector<std::string> types;
|
||||
std::vector<RequireData> requireData;
|
||||
};
|
||||
|
||||
struct ExtensionData
|
||||
@ -196,14 +205,13 @@ private:
|
||||
, xmlLine( line )
|
||||
{}
|
||||
|
||||
std::vector<std::string> commands;
|
||||
std::string deprecatedBy;
|
||||
std::string number;
|
||||
std::string obsoletedBy;
|
||||
std::string platform;
|
||||
std::string promotedTo;
|
||||
std::map<std::string, int> requirements;
|
||||
std::vector<std::string> types;
|
||||
std::set<std::string> requiresAttribute;
|
||||
std::vector<RequireData> requireData;
|
||||
int xmlLine;
|
||||
};
|
||||
|
||||
@ -308,9 +316,9 @@ private:
|
||||
|
||||
private:
|
||||
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;
|
||||
void appendDispatchLoaderDynamicCommands( std::vector<std::string> const & commands,
|
||||
void appendDispatchLoaderDynamicCommands( std::vector<RequireData> const & requireData,
|
||||
std::set<std::string> & listedCommands,
|
||||
std::string const & title,
|
||||
std::string & commandMembers,
|
||||
@ -844,7 +852,7 @@ private:
|
||||
std::map<size_t, std::vector<size_t>> const & countToVectorMap,
|
||||
std::set<size_t> const & skippedParams ) const;
|
||||
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 containsUnion( std::string const & type ) const;
|
||||
size_t determineDefaultStartIndex( std::vector<ParamData> const & params,
|
||||
@ -874,14 +882,14 @@ private:
|
||||
void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
|
||||
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 generateBitmasks( std::vector<std::string> const & types,
|
||||
std::string generateBitmasks( std::vector<RequireData> const & requireData,
|
||||
std::set<std::string> & listedBitmasks,
|
||||
std::string const & title ) const;
|
||||
std::string generateCommand( std::string const & name,
|
||||
CommandData const & commandData,
|
||||
size_t initialSkipCount,
|
||||
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::string const & title ) 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,
|
||||
CommandData const & commandData,
|
||||
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::string const & title ) 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<EnumValueData> const & values,
|
||||
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::string const & title ) const;
|
||||
std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const;
|
||||
@ -1068,7 +1076,7 @@ private:
|
||||
bool isTemplateParam ) const;
|
||||
std::string generateHandle( std::pair<std::string, HandleData> const & handle,
|
||||
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
|
||||
generateLenInitializer( std::vector<MemberData>::const_iterator mit,
|
||||
std::map<std::vector<MemberData>::const_iterator,
|
||||
@ -1077,17 +1085,17 @@ private:
|
||||
std::pair<std::string, std::string> generateProtection( std::string const & referencedIn,
|
||||
std::string const & protect ) 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::string const & title ) const;
|
||||
std::string generateSizeCheck( std::vector<std::vector<MemberData>::const_iterator> const & arrayIts,
|
||||
std::string const & structName,
|
||||
std::string const & prefix,
|
||||
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::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::string getVectorSize( std::vector<ParamData> const & params,
|
||||
std::map<size_t, size_t> const & vectorParamIndices,
|
||||
@ -1130,28 +1138,31 @@ private:
|
||||
void readExtensionRequire( tinyxml2::XMLElement const * element,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt );
|
||||
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,
|
||||
std::map<std::string, ExtensionData>::iterator extensionIt );
|
||||
std::string const & extensionName,
|
||||
RequireData & requireData );
|
||||
void readExtensions( tinyxml2::XMLElement const * element );
|
||||
void readFeature( tinyxml2::XMLElement const * element );
|
||||
void readFeatureRequire( tinyxml2::XMLElement const * element,
|
||||
std::map<std::string, FeatureData>::iterator featureIt );
|
||||
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,
|
||||
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 readHandle( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
||||
std::pair<NameData, TypeInfo> readNameAndType( tinyxml2::XMLElement const * elements );
|
||||
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::map<std::string, ExtensionData>::iterator extensionIt );
|
||||
void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extensionName );
|
||||
void readRequireEnum( tinyxml2::XMLElement const * element,
|
||||
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,
|
||||
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::set<std::string> & listedHandles,
|
||||
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 );
|
||||
std::string toString( TypeCategory category );
|
||||
|
||||
|
||||
@ -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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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 ===
|
||||
|
||||
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
|
||||
{
|
||||
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
|
||||
{
|
||||
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 ===
|
||||
|
||||
enum class DriverId
|
||||
|
||||
Loading…
Reference in New Issue
Block a user