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

Introduce extension inspection function vk::getExtensionDepends. (#1558)

Browse Source
This commit is contained in:
Andreas Süßenbach 2023-04-11 17:49:02 +02:00 committed by GitHub
parent d1d80ae723
commit 9de0959474
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 962 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

161
VulkanHppGenerator.cpp
View File

@ -137,19 +137,20 @@ namespace VULKAN_HPP_NAMESPACE
//=== Extension inspection functions === //=== Extension inspection functions ===
//====================================== //======================================
std::set<std::string> const & getDeviceExtensions(); std::set<std::string> const & getDeviceExtensions();
std::set<std::string> const & getInstanceExtensions(); std::set<std::string> const & getInstanceExtensions();
std::map<std::string, std::string> const & getDeprecatedExtensions(); std::map<std::string, std::string> const & getDeprecatedExtensions();
std::map<std::string, std::string> const & getObsoletedExtensions(); std::map<std::string, std::vector<std::string>> const & getExtensionDepends( std::string const & extension );
std::map<std::string, std::string> const & getPromotedExtensions(); std::map<std::string, std::string> const & getObsoletedExtensions();
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ); std::map<std::string, std::string> const & getPromotedExtensions();
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension );
//===================================================== //=====================================================
//=== Extension inspection function implementations === //=== Extension inspection function implementations ===
@ -173,6 +174,14 @@ namespace VULKAN_HPP_NAMESPACE
return instanceExtensions; return instanceExtensions;
} }
VULKAN_HPP_INLINE std::map<std::string, std::vector<std::string>> const & getExtensionDepends( std::string const & extension )
{
static std::map<std::string, std::vector<std::string>> noDependencies;
static std::map<std::string, std::map<std::string, std::vector<std::string>>> dependencies = { ${extensionDependencies} };
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
}
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions() VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
{ {
static std::map<std::string, std::string> obsoletedExtensions = { ${obsoletedExtensions} }; static std::map<std::string, std::string> obsoletedExtensions = { ${obsoletedExtensions} };
@ -185,46 +194,46 @@ namespace VULKAN_HPP_NAMESPACE
return promotedExtensions; return promotedExtensions;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension )
{ {
${voidName} ${voidExtension}
${deprecatedBy} ${deprecatedBy}
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension )
{ {
${voidName} ${voidExtension}
${obsoletedBy} ${obsoletedBy}
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension )
{ {
${promotedTo} ${promotedTo}
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension )
{ {
${voidName} ${voidExtension}
return ${deprecatedTest}; return ${deprecatedTest};
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
{ {
return ${deviceTest}; return ${deviceTest};
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
{ {
return ${instanceTest}; return ${instanceTest};
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )
{ {
${voidName} ${voidExtension}
return ${obsoletedTest}; return ${obsoletedTest};
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension )
{ {
return ${promotedTest}; return ${promotedTest};
} }
@ -245,6 +254,7 @@ namespace VULKAN_HPP_NAMESPACE
generateExtensionReplacedBy( []( ExtensionData const & extension ) { return extension.isDeprecated; }, generateExtensionReplacedBy( []( ExtensionData const & extension ) { return extension.isDeprecated; },
[]( ExtensionData const & extension ) { return extension.deprecatedBy; } ) }, []( ExtensionData const & extension ) { return extension.deprecatedBy; } ) },
{ "deprecatedTest", generateExtensionReplacedTest( []( ExtensionData const & extension ) { return extension.isDeprecated; } ) }, { "deprecatedTest", generateExtensionReplacedTest( []( ExtensionData const & extension ) { return extension.isDeprecated; } ) },
{ "extensionDependencies", generateExtensionDependencies() },
{ "instanceExtensions", generateExtensionsList( "instance" ) }, { "instanceExtensions", generateExtensionsList( "instance" ) },
{ "instanceTest", generateExtensionTypeTest( "instance" ) }, { "instanceTest", generateExtensionTypeTest( "instance" ) },
{ "licenseHeader", m_vulkanLicenseHeader }, { "licenseHeader", m_vulkanLicenseHeader },
@ -262,7 +272,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "promotedTo", { "promotedTo",
generateExtensionReplacedBy( []( ExtensionData const & extension ) { return !extension.promotedTo.empty(); }, generateExtensionReplacedBy( []( ExtensionData const & extension ) { return !extension.promotedTo.empty(); },
[]( ExtensionData const & extension ) { return extension.promotedTo; } ) }, []( ExtensionData const & extension ) { return extension.promotedTo; } ) },
{ "voidName", ( m_api == "vulkan" ) ? "" : "(void)name;" } } ); { "voidExtension", ( m_api == "vulkan" ) ? "" : "(void)extension;" } } );
writeToFile( str, vulkan_extension_inspection_hpp ); writeToFile( str, vulkan_extension_inspection_hpp );
} }
@ -1174,10 +1184,15 @@ void VulkanHppGenerator::checkExtensionCorrectness() const
for ( auto const & extension : m_extensions ) for ( auto const & extension : m_extensions )
{ {
// check for existence of any depends, deprecation, obsoletion, or promotion // check for existence of any depends, deprecation, obsoletion, or promotion
for ( auto const & depends : extension.depends ) for ( auto const & dependsPerVersion : extension.depends )
{ {
checkForError( checkForError( isFeature( dependsPerVersion.first ),
isFeature( depends ) || isExtension( depends ), extension.xmlLine, "extension <" + extension.name + "> lists an unknown depends <" + depends + ">" ); extension.xmlLine,
"extension <" + extension.name + "> lists an unknown feature <" + dependsPerVersion.first + ">" );
for ( auto const & depends : dependsPerVersion.second )
{
checkForError( isExtension( depends ), extension.xmlLine, "extension <" + extension.name + "> lists an unknown depends <" + depends + ">" );
}
} }
if ( !extension.deprecatedBy.empty() ) if ( !extension.deprecatedBy.empty() )
{ {
@ -5658,6 +5673,48 @@ std::string VulkanHppGenerator::generateEnumValueName( std::string const & enumN
return result; return result;
} }
std::string VulkanHppGenerator::generateExtensionDependencies() const
{
std::string extensionDependencies, previousEnter, previousLeave;
for (auto const& extension : m_extensions)
{
if ( !extension.depends.empty() )
{
std::string dependsPerExtension = "{ \"" + extension.name + "\", { ";
for ( auto const & dependsPerVersion : extension.depends )
{
dependsPerExtension += "{ \"" + dependsPerVersion.first + "\", { ";
if ( !dependsPerVersion.second.empty() )
{
for ( auto const & depends : dependsPerVersion.second )
{
dependsPerExtension += "\"" + depends + "\", ";
}
assert( dependsPerExtension.ends_with( ", " ) );
dependsPerExtension = dependsPerExtension.substr( 0, dependsPerExtension.length() - 2 );
}
dependsPerExtension += " } }, ";
}
assert( dependsPerExtension.ends_with( ", " ) );
dependsPerExtension = dependsPerExtension.substr( 0, dependsPerExtension.length() - 2 );
dependsPerExtension += " } }, ";
auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) );
extensionDependencies += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + dependsPerExtension;
previousEnter = enter;
previousLeave = leave;
}
}
assert( extensionDependencies.ends_with( ", " ) );
extensionDependencies = extensionDependencies.substr( 0, extensionDependencies.length() - 2 );
if ( !previousLeave.empty() )
{
extensionDependencies += "\n" + previousLeave;
}
return extensionDependencies;
}
template <class Predicate, class Extraction> template <class Predicate, class Extraction>
std::string VulkanHppGenerator::generateExtensionReplacedBy( Predicate p, Extraction e ) const std::string VulkanHppGenerator::generateExtensionReplacedBy( Predicate p, Extraction e ) const
{ {
@ -5667,7 +5724,7 @@ std::string VulkanHppGenerator::generateExtensionReplacedBy( Predicate p, Extrac
if ( p( extension ) ) if ( p( extension ) )
{ {
auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) ); auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) );
replacedBy += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " if ( name == \"" + extension.name + "\" ) { return \"" + replacedBy += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " if ( extension == \"" + extension.name + "\" ) { return \"" +
e( extension ) + "\"; }"; e( extension ) + "\"; }";
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
@ -5692,7 +5749,7 @@ std::string VulkanHppGenerator::generateExtensionReplacedTest( Predicate p ) con
{ {
auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) ); auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) );
unprotectedEntry |= enter.empty(); unprotectedEntry |= enter.empty();
replacedTest += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + "( name == \"" + extension.name + "\" ) || "; replacedTest += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + "( extension == \"" + extension.name + "\" ) || ";
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
} }
@ -5743,7 +5800,7 @@ std::string VulkanHppGenerator::generateExtensionTypeTest( std::string const & t
if ( extension.type == type ) if ( extension.type == type )
{ {
auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) ); auto [enter, leave] = generateProtection( getProtectFromTitle( extension.name ) );
typeTest += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + "( name == \"" + extension.name + "\" ) || "; typeTest += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + "( extension == \"" + extension.name + "\" ) || ";
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
} }
@ -11705,8 +11762,44 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element )
{ {
if ( attribute.first == "depends" ) if ( attribute.first == "depends" )
{ {
// we don't care about the logical implications of ',' and '+' here, we're just interested to get the depends strings // currently, we map the few complex depends attributes to a canonical format!
extensionData.depends = tokenizeAny( attribute.second, ",+()" ); const std::map<std::string, std::string> complexToCanonicalDepends = {
{ "VK_KHR_swapchain+VK_KHR_get_surface_capabilities2+(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)",
"VK_KHR_swapchain+VK_KHR_get_surface_capabilities2+VK_KHR_get_physical_device_properties2, VK_VERSION_1_1+VK_KHR_swapchain+VK_KHR_get_surface_capabilities2" },
{ "((VK_KHR_bind_memory2+VK_KHR_get_physical_device_properties2+VK_KHR_sampler_ycbcr_conversion),VK_VERSION_1_1)+(VK_KHR_image_format_list,VK_VERSION_1_2)",
"VK_KHR_bind_memory2+VK_KHR_get_physical_device_properties2+VK_KHR_sampler_ycbcr_conversion+VK_KHR_image_format_list,VK_VERSION_1_1+VK_KHR_image_format_list,VK_VERSION_1_2" },
{ "VK_KHR_swapchain+(VK_KHR_maintenance2,VK_VERSION_1_1)+(VK_KHR_image_format_list,VK_VERSION_1_2)",
"VK_KHR_swapchain+VK_KHR_maintenance2+VK_KHR_image_format_list,VK_VERSION_1_1+VK_KHR_swapchain+VK_KHR_image_format_list,VK_VERSION_1_2+VK_KHR_swapchain" },
{ "(VK_KHR_create_renderpass2,VK_VERSION_1_2)+(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)",
"VK_KHR_create_renderpass2+VK_KHR_get_physical_device_properties2,VK_VERSION_1_1+VK_KHR_create_renderpass2,VK_VERSION_1_2" },
{ "(VK_KHR_get_physical_device_properties2+VK_KHR_device_group),VK_VERSION_1_1",
"VK_KHR_get_physical_device_properties2+VK_KHR_device_group,VK_VERSION_1_1" },
{ "(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+(VK_KHR_dynamic_rendering,VK_VERSION_1_3)",
"VK_KHR_get_physical_device_properties2+VK_KHR_dynamic_rendering,VK_VERSION_1_1+VK_KHR_dynamic_rendering,VK_VERSION_1_3" }
};
auto canonicalIt = complexToCanonicalDepends.find( attribute.second );
std::string depends = ( canonicalIt == complexToCanonicalDepends.end() ) ? attribute.second : canonicalIt->second;
checkForError( depends.find( '(' ) == std::string::npos, line, "encountered not-yet-handled complex attribute depends=\"" + depends + "\"" );
// for ease of handling, prepend the (optional) VK_VERSION_1_0
if ( !depends.starts_with( "VK_VERSION" ) )
{
depends = "VK_VERSION_1_0+" + depends;
}
// first tokenize by ',', giving a vector of dependencies for different vulkan versions
std::vector<std::string> allDependencies = tokenize( depends, "," );
for ( auto dep : allDependencies )
{
// then tokenize by '+', giving a vector of dependendies for the vulkan version listed as the first element here
std::vector<std::string> dependsPerVersion = tokenize( dep, "+" );
assert( dependsPerVersion[0].starts_with( "VK_VERSION_" ) );
assert( std::find_if( std::next( dependsPerVersion.begin() ),
dependsPerVersion.end(),
[]( std::string const & d ) { return d.starts_with( "VK_VERSION_" ); } ) == dependsPerVersion.end() );
assert( extensionData.depends.find( dependsPerVersion[0] ) == extensionData.depends.end() );
extensionData.depends[dependsPerVersion[0]] = { std::next( dependsPerVersion.begin() ), dependsPerVersion.end() };
}
} }
else if ( attribute.first == "deprecatedby" ) else if ( attribute.first == "deprecatedby" )
{ {

23
VulkanHppGenerator.hpp
View File

@ -242,17 +242,17 @@ private:
struct ExtensionData struct ExtensionData
{ {
std::string deprecatedBy = {}; std::string deprecatedBy = {};
bool isDeprecated = false; bool isDeprecated = false;
std::string name = {}; std::string name = {};
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::vector<std::string> depends = {}; std::map<std::string, std::vector<std::string>> depends = {};
std::vector<RequireData> requireData = {}; std::vector<RequireData> requireData = {};
std::string type = {}; std::string type = {};
int xmlLine = 0; int xmlLine = 0;
}; };
struct ExternalTypeData struct ExternalTypeData
@ -693,6 +693,7 @@ private:
std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const; std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const;
std::pair<std::string, std::string> generateEnumSuffixes( std::string const & name, bool bitmask ) const; std::pair<std::string, std::string> generateEnumSuffixes( std::string const & name, bool bitmask ) const;
std::string generateEnumValueName( std::string const & enumName, std::string const & valueName, bool bitmask ) const; std::string generateEnumValueName( std::string const & enumName, std::string const & valueName, bool bitmask ) const;
std::string generateExtensionDependencies() const;
template <class Predicate, class Extraction> template <class Predicate, class Extraction>
std::string generateExtensionReplacedBy( Predicate p, Extraction e ) const; std::string generateExtensionReplacedBy( Predicate p, Extraction e ) const;
template <class Predicate> template <class Predicate>

6
tests/ExtensionInspection/ExtensionInspection.cpp
View File

@ -22,7 +22,7 @@
# pragma clang diagnostic ignored "-Wunused-variable" # pragma clang diagnostic ignored "-Wunused-variable"
#elif defined( __GNUC__ ) #elif defined( __GNUC__ )
# pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic ignored "-Wunused-variable"
# pragma GCC diagnostic ignored "-Wunused-but-set-variable" # pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#else #else
// unknow compiler... just ignore the warnings for yourselves ;) // unknow compiler... just ignore the warnings for yourselves ;)
#endif #endif
@ -49,6 +49,10 @@ int main( int /*argc*/, char ** /*argv*/ )
std::set<std::string> const & deviceExtensions = vk::getDeviceExtensions(); std::set<std::string> const & deviceExtensions = vk::getDeviceExtensions();
assert( deviceExtensions.find( VK_KHR_SWAPCHAIN_EXTENSION_NAME ) != deviceExtensions.end() ); assert( deviceExtensions.find( VK_KHR_SWAPCHAIN_EXTENSION_NAME ) != deviceExtensions.end() );
std::map<std::string, std::vector<std::string>> depends = vk::getExtensionDepends( VK_KHR_SWAPCHAIN_EXTENSION_NAME );
assert( ( depends.size() == 1 ) && ( depends.begin()->first == "VK_VERSION_1_0" ) && ( depends.begin()->second.size() == 1 ) &&
( depends.begin()->second[0] == VK_KHR_DISPLAY_EXTENSION_NAME ) );
std::map<std::string, std::string> const & deprecatedExtensions = vk::getDeprecatedExtensions(); std::map<std::string, std::string> const & deprecatedExtensions = vk::getDeprecatedExtensions();
auto deprecatedIt = deprecatedExtensions.find( VK_EXT_DEBUG_REPORT_EXTENSION_NAME ); auto deprecatedIt = deprecatedExtensions.find( VK_EXT_DEBUG_REPORT_EXTENSION_NAME );
assert( ( deprecatedIt != deprecatedExtensions.end() ) && ( deprecatedIt->second == VK_EXT_DEBUG_UTILS_EXTENSION_NAME ) ); assert( ( deprecatedIt != deprecatedExtensions.end() ) && ( deprecatedIt->second == VK_EXT_DEBUG_UTILS_EXTENSION_NAME ) );

948
vulkan/vulkan_extension_inspection.hpp
View File

File diff suppressed because it is too large Load Diff

230
vulkan/vulkansc_extension_inspection.hpp
View File

@ -18,19 +18,20 @@ namespace VULKAN_HPP_NAMESPACE
//=== Extension inspection functions === //=== Extension inspection functions ===
//====================================== //======================================
std::set<std::string> const & getDeviceExtensions(); std::set<std::string> const & getDeviceExtensions();
std::set<std::string> const & getInstanceExtensions(); std::set<std::string> const & getInstanceExtensions();
std::map<std::string, std::string> const & getDeprecatedExtensions(); std::map<std::string, std::string> const & getDeprecatedExtensions();
std::map<std::string, std::string> const & getObsoletedExtensions(); std::map<std::string, std::vector<std::string>> const & getExtensionDepends( std::string const & extension );
std::map<std::string, std::string> const & getPromotedExtensions(); std::map<std::string, std::string> const & getObsoletedExtensions();
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ); std::map<std::string, std::string> const & getPromotedExtensions();
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & name ); VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension );
VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension );
//===================================================== //=====================================================
//=== Extension inspection function implementations === //=== Extension inspection function implementations ===
@ -132,6 +133,90 @@ namespace VULKAN_HPP_NAMESPACE
return instanceExtensions; return instanceExtensions;
} }
VULKAN_HPP_INLINE std::map<std::string, std::vector<std::string>> const & getExtensionDepends( std::string const & extension )
{
static std::map<std::string, std::vector<std::string>> noDependencies;
static std::map<std::string, std::map<std::string, std::vector<std::string>>> dependencies = {
{ "VK_KHR_swapchain", { { "VK_VERSION_1_0", { "VK_KHR_surface" } } } },
{ "VK_KHR_display", { { "VK_VERSION_1_0", { "VK_KHR_surface" } } } },
{ "VK_KHR_display_swapchain", { { "VK_VERSION_1_0", { "VK_KHR_swapchain", "VK_KHR_display" } } } },
{ "VK_EXT_texture_compression_astc_hdr", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_astc_decode_mode", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_external_memory_fd", { { "VK_VERSION_1_0", { "VK_KHR_external_memory" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_external_semaphore_fd", { { "VK_VERSION_1_0", { "VK_KHR_external_semaphore" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_incremental_present", { { "VK_VERSION_1_0", { "VK_KHR_swapchain" } } } },
{ "VK_EXT_direct_mode_display", { { "VK_VERSION_1_0", { "VK_KHR_display" } } } },
{ "VK_EXT_display_surface_counter", { { "VK_VERSION_1_0", { "VK_KHR_display" } } } },
{ "VK_EXT_display_control", { { "VK_VERSION_1_0", { "VK_EXT_display_surface_counter", "VK_KHR_swapchain" } } } },
{ "VK_EXT_discard_rectangles", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_conservative_rasterization", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_depth_clip_enable", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_swapchain_colorspace", { { "VK_VERSION_1_0", { "VK_KHR_surface" } } } },
{ "VK_EXT_hdr_metadata", { { "VK_VERSION_1_0", { "VK_KHR_swapchain" } } } },
{ "VK_KHR_shared_presentable_image",
{ { "VK_VERSION_1_0", { "VK_KHR_swapchain", "VK_KHR_get_surface_capabilities2", "VK_KHR_get_physical_device_properties2" } },
{ "VK_VERSION_1_1", { "VK_KHR_swapchain", "VK_KHR_get_surface_capabilities2" } } } },
{ "VK_KHR_external_fence_fd", { { "VK_VERSION_1_0", { "VK_KHR_external_fence" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_performance_query", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_get_surface_capabilities2", { { "VK_VERSION_1_0", { "VK_KHR_surface" } } } },
{ "VK_KHR_get_display_properties2", { { "VK_VERSION_1_0", { "VK_KHR_display" } } } },
{ "VK_EXT_external_memory_dma_buf", { { "VK_VERSION_1_0", { "VK_KHR_external_memory_fd" } } } },
{ "VK_EXT_queue_family_foreign", { { "VK_VERSION_1_0", { "VK_KHR_external_memory" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_sample_locations", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_blend_operation_advanced", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_image_drm_format_modifier",
{ { "VK_VERSION_1_0",
{ "VK_KHR_bind_memory2", "VK_KHR_get_physical_device_properties2", "VK_KHR_sampler_ycbcr_conversion", "VK_KHR_image_format_list" } },
{ "VK_VERSION_1_1", { "VK_KHR_image_format_list" } },
{ "VK_VERSION_1_2", {} } } },
{ "VK_EXT_external_memory_host", { { "VK_VERSION_1_0", { "VK_KHR_external_memory" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_shader_clock", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_calibrated_timestamps", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_vertex_attribute_divisor", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_swapchain_mutable_format",
{ { "VK_VERSION_1_0", { "VK_KHR_swapchain", "VK_KHR_maintenance2", "VK_KHR_image_format_list" } },
{ "VK_VERSION_1_1", { "VK_KHR_swapchain", "VK_KHR_image_format_list" } },
{ "VK_VERSION_1_2", { "VK_KHR_swapchain" } } } },
{ "VK_EXT_pci_bus_info", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_shader_terminate_invocation", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_subgroup_size_control", { { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_fragment_shading_rate",
{ { "VK_VERSION_1_0", { "VK_KHR_create_renderpass2", "VK_KHR_get_physical_device_properties2" } },
{ "VK_VERSION_1_1", { "VK_KHR_create_renderpass2" } },
{ "VK_VERSION_1_2", {} } } },
{ "VK_EXT_shader_image_atomic_int64", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_memory_budget", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_fragment_shader_interlock", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_ycbcr_image_arrays", { { "VK_VERSION_1_0", { "VK_KHR_sampler_ycbcr_conversion" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_headless_surface", { { "VK_VERSION_1_0", { "VK_KHR_surface" } } } },
{ "VK_EXT_line_rasterization", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_shader_atomic_float", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_index_type_uint8", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_extended_dynamic_state", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_shader_demote_to_helper_invocation", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_texel_buffer_alignment", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_robustness2", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_custom_border_color", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_synchronization2", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_ycbcr_2plane_444_formats", { { "VK_VERSION_1_0", { "VK_KHR_sampler_ycbcr_conversion" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_image_robustness", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_KHR_copy_commands2", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_4444_formats", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_vertex_input_dynamic_state", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
#if defined( VK_USE_PLATFORM_SCI )
{ "VK_NV_external_sci_sync", { { "VK_VERSION_1_1", {} } } },
{ "VK_NV_external_memory_sci_buf", { { "VK_VERSION_1_1", {} } } },
#endif /*VK_USE_PLATFORM_SCI*/
{ "VK_EXT_extended_dynamic_state2", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
{ "VK_EXT_color_write_enable", { { "VK_VERSION_1_0", { "VK_KHR_get_physical_device_properties2" } }, { "VK_VERSION_1_1", {} } } },
#if defined( VK_USE_PLATFORM_SCI )
{ "VK_NV_external_sci_sync2", { { "VK_VERSION_1_1", {} } } }
#endif /*VK_USE_PLATFORM_SCI*/
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
}
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions() VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
{ {
static std::map<std::string, std::string> obsoletedExtensions = {}; static std::map<std::string, std::string> obsoletedExtensions = {};
@ -156,12 +241,12 @@ namespace VULKAN_HPP_NAMESPACE
return promotedExtensions; return promotedExtensions;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension )
{ {
(void)name; (void)extension;
#if defined( VK_USE_PLATFORM_SCI ) #if defined( VK_USE_PLATFORM_SCI )
if ( name == "VK_NV_external_sci_sync" ) if ( extension == "VK_NV_external_sci_sync" )
{ {
return "VK_NV_external_sci_sync2"; return "VK_NV_external_sci_sync2";
} }
@ -170,132 +255,135 @@ namespace VULKAN_HPP_NAMESPACE
return ""; return "";
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension )
{ {
(void)name; (void)extension;
return ""; return "";
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension )
{ {
if ( name == "VK_EXT_texture_compression_astc_hdr" ) if ( extension == "VK_EXT_texture_compression_astc_hdr" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_global_priority" ) if ( extension == "VK_EXT_global_priority" )
{ {
return "VK_KHR_global_priority"; return "VK_KHR_global_priority";
} }
if ( name == "VK_KHR_shader_terminate_invocation" ) if ( extension == "VK_KHR_shader_terminate_invocation" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_subgroup_size_control" ) if ( extension == "VK_EXT_subgroup_size_control" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_extended_dynamic_state" ) if ( extension == "VK_EXT_extended_dynamic_state" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_shader_demote_to_helper_invocation" ) if ( extension == "VK_EXT_shader_demote_to_helper_invocation" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_texel_buffer_alignment" ) if ( extension == "VK_EXT_texel_buffer_alignment" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_KHR_synchronization2" ) if ( extension == "VK_KHR_synchronization2" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_ycbcr_2plane_444_formats" ) if ( extension == "VK_EXT_ycbcr_2plane_444_formats" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_image_robustness" ) if ( extension == "VK_EXT_image_robustness" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_KHR_copy_commands2" ) if ( extension == "VK_KHR_copy_commands2" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_4444_formats" ) if ( extension == "VK_EXT_4444_formats" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
if ( name == "VK_EXT_extended_dynamic_state2" ) if ( extension == "VK_EXT_extended_dynamic_state2" )
{ {
return "VK_VERSION_1_3"; return "VK_VERSION_1_3";
} }
return ""; return "";
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension )
{ {
(void)name; (void)extension;
return return
#if defined( VK_USE_PLATFORM_SCI ) #if defined( VK_USE_PLATFORM_SCI )
( name == "VK_NV_external_sci_sync" ) || ( extension == "VK_NV_external_sci_sync" ) ||
#endif /*VK_USE_PLATFORM_SCI*/ #endif /*VK_USE_PLATFORM_SCI*/
false; false;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
{ {
return ( name == "VK_KHR_swapchain" ) || ( name == "VK_KHR_display_swapchain" ) || ( name == "VK_EXT_depth_range_unrestricted" ) || return ( extension == "VK_KHR_swapchain" ) || ( extension == "VK_KHR_display_swapchain" ) || ( extension == "VK_EXT_depth_range_unrestricted" ) ||
( name == "VK_NV_private_vendor_info" ) || ( name == "VK_EXT_texture_compression_astc_hdr" ) || ( name == "VK_EXT_astc_decode_mode" ) || ( extension == "VK_NV_private_vendor_info" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) ||
( name == "VK_KHR_external_memory_fd" ) || ( name == "VK_KHR_external_semaphore_fd" ) || ( name == "VK_KHR_incremental_present" ) || ( extension == "VK_EXT_astc_decode_mode" ) || ( extension == "VK_KHR_external_memory_fd" ) || ( extension == "VK_KHR_external_semaphore_fd" ) ||
( name == "VK_EXT_display_control" ) || ( name == "VK_EXT_discard_rectangles" ) || ( name == "VK_EXT_conservative_rasterization" ) || ( extension == "VK_KHR_incremental_present" ) || ( extension == "VK_EXT_display_control" ) || ( extension == "VK_EXT_discard_rectangles" ) ||
( name == "VK_EXT_depth_clip_enable" ) || ( name == "VK_EXT_hdr_metadata" ) || ( name == "VK_KHR_shared_presentable_image" ) || ( extension == "VK_EXT_conservative_rasterization" ) || ( extension == "VK_EXT_depth_clip_enable" ) || ( extension == "VK_EXT_hdr_metadata" ) ||
( name == "VK_KHR_external_fence_fd" ) || ( name == "VK_KHR_performance_query" ) || ( name == "VK_EXT_external_memory_dma_buf" ) || ( extension == "VK_KHR_shared_presentable_image" ) || ( extension == "VK_KHR_external_fence_fd" ) || ( extension == "VK_KHR_performance_query" ) ||
( name == "VK_EXT_queue_family_foreign" ) || ( name == "VK_EXT_shader_stencil_export" ) || ( name == "VK_EXT_sample_locations" ) || ( extension == "VK_EXT_external_memory_dma_buf" ) || ( extension == "VK_EXT_queue_family_foreign" ) ||
( name == "VK_EXT_blend_operation_advanced" ) || ( name == "VK_EXT_post_depth_coverage" ) || ( name == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
( name == "VK_EXT_filter_cubic" ) || ( name == "VK_EXT_global_priority" ) || ( name == "VK_EXT_external_memory_host" ) || ( extension == "VK_EXT_blend_operation_advanced" ) || ( extension == "VK_EXT_post_depth_coverage" ) ||
( name == "VK_KHR_shader_clock" ) || ( name == "VK_EXT_calibrated_timestamps" ) || ( name == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_filter_cubic" ) || ( extension == "VK_EXT_global_priority" ) ||
( name == "VK_KHR_swapchain_mutable_format" ) || ( name == "VK_EXT_pci_bus_info" ) || ( name == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
( name == "VK_EXT_subgroup_size_control" ) || ( name == "VK_KHR_fragment_shading_rate" ) || ( name == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_KHR_swapchain_mutable_format" ) || ( extension == "VK_EXT_pci_bus_info" ) ||
( name == "VK_EXT_memory_budget" ) || ( name == "VK_EXT_fragment_shader_interlock" ) || ( name == "VK_EXT_ycbcr_image_arrays" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_subgroup_size_control" ) ||
( name == "VK_EXT_line_rasterization" ) || ( name == "VK_EXT_shader_atomic_float" ) || ( name == "VK_EXT_index_type_uint8" ) || ( extension == "VK_KHR_fragment_shading_rate" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_EXT_memory_budget" ) ||
( name == "VK_EXT_extended_dynamic_state" ) || ( name == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) ||
( name == "VK_EXT_texel_buffer_alignment" ) || ( name == "VK_EXT_robustness2" ) || ( name == "VK_EXT_custom_border_color" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_shader_atomic_float" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
( name == "VK_KHR_object_refresh" ) || ( name == "VK_KHR_synchronization2" ) || ( name == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
( name == "VK_EXT_image_robustness" ) || ( name == "VK_KHR_copy_commands2" ) || ( name == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_EXT_custom_border_color" ) ||
( name == "VK_EXT_vertex_input_dynamic_state" ) || ( extension == "VK_KHR_object_refresh" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
( extension == "VK_EXT_vertex_input_dynamic_state" ) ||
#if defined( VK_USE_PLATFORM_SCI ) #if defined( VK_USE_PLATFORM_SCI )
( name == "VK_NV_external_sci_sync" ) || ( name == "VK_NV_external_memory_sci_buf" ) || ( extension == "VK_NV_external_sci_sync" ) || ( extension == "VK_NV_external_memory_sci_buf" ) ||
#endif /*VK_USE_PLATFORM_SCI*/ #endif /*VK_USE_PLATFORM_SCI*/
( name == "VK_EXT_extended_dynamic_state2" ) || ( name == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_color_write_enable" ) ||
#if defined( VK_USE_PLATFORM_SCI ) #if defined( VK_USE_PLATFORM_SCI )
( name == "VK_NV_external_sci_sync2" ) ( extension == "VK_NV_external_sci_sync2" )
#endif /*VK_USE_PLATFORM_SCI*/ #endif /*VK_USE_PLATFORM_SCI*/
; ;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
{ {
return ( name == "VK_KHR_surface" ) || ( name == "VK_KHR_display" ) || ( name == "VK_EXT_direct_mode_display" ) || return ( extension == "VK_KHR_surface" ) || ( extension == "VK_KHR_display" ) || ( extension == "VK_EXT_direct_mode_display" ) ||
( name == "VK_EXT_display_surface_counter" ) || ( name == "VK_EXT_swapchain_colorspace" ) || ( name == "VK_KHR_get_surface_capabilities2" ) || ( extension == "VK_EXT_display_surface_counter" ) || ( extension == "VK_EXT_swapchain_colorspace" ) ||
( name == "VK_KHR_get_display_properties2" ) || ( name == "VK_EXT_debug_utils" ) || ( name == "VK_EXT_validation_features" ) || ( extension == "VK_KHR_get_surface_capabilities2" ) || ( extension == "VK_KHR_get_display_properties2" ) || ( extension == "VK_EXT_debug_utils" ) ||
( name == "VK_EXT_headless_surface" ) || ( name == "VK_EXT_application_parameters" ); ( extension == "VK_EXT_validation_features" ) || ( extension == "VK_EXT_headless_surface" ) || ( extension == "VK_EXT_application_parameters" );
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )
{ {
(void)name; (void)extension;
return false; return false;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & name ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension )
{ {
return ( name == "VK_EXT_texture_compression_astc_hdr" ) || ( name == "VK_EXT_global_priority" ) || ( name == "VK_KHR_shader_terminate_invocation" ) || return ( extension == "VK_EXT_texture_compression_astc_hdr" ) || ( extension == "VK_EXT_global_priority" ) ||
( name == "VK_EXT_subgroup_size_control" ) || ( name == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_subgroup_size_control" ) ||
( name == "VK_EXT_shader_demote_to_helper_invocation" ) || ( name == "VK_EXT_texel_buffer_alignment" ) || ( name == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
( name == "VK_EXT_ycbcr_2plane_444_formats" ) || ( name == "VK_EXT_image_robustness" ) || ( name == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_KHR_synchronization2" ) ||
( name == "VK_EXT_4444_formats" ) || ( name == "VK_EXT_extended_dynamic_state2" ); ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) ||
( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_extended_dynamic_state2" );
} }
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE