mewin/vulkan-hpp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added from_string methods.

Browse Source
This commit is contained in:
Patrick 2023-12-03 13:53:13 +01:00
parent 84b77d1406
commit fdf6c443af
5 changed files with 7671 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
VulkanHppGenerator.cpp
View File

@ -478,6 +478,10 @@ ${baseTypes}
#include <vulkan/${api}_to_string.hpp>
#endif
#if !defined( VULKAN_HPP_NO_FROM_STRING )
#include <vulkan/${api}_from_string.hpp>
#endif
#ifndef VULKAN_HPP_NO_EXCEPTIONS
namespace std
{
@ -776,6 +780,34 @@ ${enumsToString}
writeToFile( str, vulkan_to_string_hpp );
}
void VulkanHppGenerator::generateFromStringHppFile() const
{
std::string const vulkan_from_string_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_from_string.hpp";
std::cout << "VulkanHppGenerator: Generating " << vulkan_from_string_hpp << "..." << std::endl;
std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
#ifndef VULKAN_FROM_STRING_HPP
# define VULKAN_FROM_STRING_HPP
#include <string>
#include <unordered_map>
#include <vulkan/${api}_enums.hpp>
namespace VULKAN_HPP_NAMESPACE
{
${enumsFromString}
} // namespace VULKAN_HPP_NAMESPACE
#endif
)";
std::string str = replaceWithMap( vulkanHandlesHppTemplate,
{ { "api", m_api },
{ "enumsFromString", generateEnumsFromString() },
{ "licenseHeader", m_vulkanLicenseHeader } } );
writeToFile( str, vulkan_from_string_hpp );
}
void VulkanHppGenerator::generateCppModuleFile() const
{
std::string const vulkan_cppm = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".cppm";
@ -6790,6 +6822,170 @@ ${functionBody}
{ { "argument", enumData.second.values.empty() ? "" : " value" }, { "enumName", enumName }, { "functionBody", functionBody } } );
}
std::string VulkanHppGenerator::generateEnumsFromString() const
{
const std::string enumsFromStringTemplate = R"(
#define VULKAN_HPP_ENUM_FROM_STRING_STORAGE \
namespace VULKAN_HPP_NAMESPACE \
{ \
VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
}
//=========================
//=== ENUMs from_string ===
//=========================
struct EnumFromStringMap
{
${enumsFromStringStorage}
};
VULKAN_HPP_STORAGE_API extern const EnumFromStringMap enumFromStringMap;
${enumsFromString}
)";
std::string enumsFromStringStorage;
std::string enumsFromString;
std::set<std::string> listedEnums;
for ( auto const & feature : m_features )
{
enumsFromStringStorage += generateEnumsFromStringStorage( feature.requireData, listedEnums, feature.name );
}
for ( auto const & extension : m_extensions )
{
enumsFromStringStorage += generateEnumsFromStringStorage( extension.requireData, listedEnums, extension.name );
}
listedEnums.clear();
for ( auto const & feature : m_features )
{
enumsFromString += generateEnumsFromString( feature.requireData, listedEnums, feature.name );
}
for ( auto const & extension : m_extensions )
{
enumsFromString += generateEnumsFromString( extension.requireData, listedEnums, extension.name );
}
return replaceWithMap( enumsFromStringTemplate, {
{ "enumsFromString", enumsFromString },
{ "enumsFromStringStorage", enumsFromStringStorage }} );
}
std::string VulkanHppGenerator::generateEnumsFromString( std::vector<RequireData> const & requireData,
std::set<std::string> & listedEnums,
std::string const & title ) const
{
std::string str;
for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{
auto enumIt = m_enums.find( type );
if ( ( enumIt != m_enums.end() ) && !listedEnums.contains( type ) )
{
listedEnums.insert( type );
str += "\n";
str += generateEnumFromString( *enumIt );
}
}
}
return addTitleAndProtection( title, str );
}
std::string VulkanHppGenerator::generateEnumFromString( std::pair<std::string, EnumData> const & enumData ) const
{
std::string enumName = stripPrefix( enumData.first, "Vk" );
std::string functionBody;
if ( enumData.second.values.empty() )
{
functionBody = R"x( return "std::nullopt";)x";
}
else
{
const std::string functionBodyTemplate =
R"x( auto it = enumFromStringMap.${enumName}.find(value);
if (it != enumFromStringMap.${enumName}.end())
{
return it->second;
}
return std::nullopt;
)x";
functionBody = replaceWithMap( functionBodyTemplate, { { "enumName", enumName } } );
}
const std::string enumFromStringTemplate = R"(
VULKAN_HPP_INLINE std::optional<${enumName}> ${enumName}_from_string( const std::string& ${argument} )
{
${functionBody}
}
)";
return replaceWithMap( enumFromStringTemplate,
{ { "argument", enumData.second.values.empty() ? "" : " value" }, { "enumName", enumName }, { "functionBody", functionBody } } );
}
std::string VulkanHppGenerator::generateEnumsFromStringStorage( std::vector<RequireData> const & requireData,
std::set<std::string> & listedEnums,
std::string const & title ) const
{
std::string str;
for ( auto const & require : requireData )
{
for ( auto const & type : require.types )
{
auto enumIt = m_enums.find( type );
if ( ( enumIt != m_enums.end() ) && !listedEnums.contains( type ) )
{
listedEnums.insert( type );
str += "\n";
str += generateEnumFromStringStorage( *enumIt );
}
}
}
return addTitleAndProtection( title, str );
}
std::string VulkanHppGenerator::generateEnumFromStringStorage( std::pair<std::string, EnumData> const & enumData ) const
{
std::string enumName = stripPrefix( enumData.first, "Vk" );
std::string entries;
std::string previousEnter, previousLeave;
for ( auto const & value : enumData.second.values )
{
// generate cases for non-alias enum values only
if ( value.alias.empty() )
{
auto [enter, leave] = generateProtection( value.protect );
if ( previousEnter != enter )
{
entries += previousLeave + enter;
}
const std::string entryTemplate = R"( { "${valueName}", ${enumName}::e${valueName} },
)";
entries += replaceWithMap(
entryTemplate,
{ { "enumName", enumName }, { "valueName", generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask ).substr( 1 ) } } );
previousEnter = enter;
previousLeave = leave;
}
}
entries += previousLeave;
const std::string enumToStringTemplate = R"(
std::unordered_map<std::string, ${enumName}> ${enumName} =
{
${entries}
};
)";
return replaceWithMap( enumToStringTemplate,
{ { "enumName", enumName }, { "entries", entries } } );
}
std::pair<std::string, std::string> VulkanHppGenerator::generateEnumSuffixes( std::string const & name, bool bitmask ) const
{
std::string prefix, postfix;
@ -15710,6 +15906,7 @@ int main( int argc, char ** argv )
generator.generateStaticAssertionsHppFile();
generator.generateStructsHppFile();
generator.generateToStringHppFile();
generator.generateFromStringHppFile();
generator.generateCppModuleFile();
#if !defined( CLANG_FORMAT_EXECUTABLE )

6
VulkanHppGenerator.hpp
View File

@ -101,6 +101,7 @@ public:
void generateStaticAssertionsHppFile() const;
void generateStructsHppFile() const;
void generateToStringHppFile() const;
void generateFromStringHppFile() const;
void generateCppModuleFile() const;
void prepareRAIIHandles();
void prepareVulkanFuncs();
@ -701,6 +702,11 @@ private:
std::string generateEnumsToString() const;
std::string generateEnumsToString( 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;
std::string generateEnumsFromString() const;
std::string generateEnumsFromString( std::vector<RequireData> const & requireData, std::set<std::string> & listedEnums, std::string const & title ) const;
std::string generateEnumFromString( std::pair<std::string, EnumData> const & enumData ) const;
std::string generateEnumsFromStringStorage( std::vector<RequireData> const & requireData, std::set<std::string> & listedEnums, std::string const & title ) const;
std::string generateEnumFromStringStorage( std::pair<std::string, EnumData> const & enumData ) 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 generateExtensionDependencies() const;

6
vulkan/vulkan.hpp
View File

@ -6072,6 +6072,10 @@ namespace VULKAN_HPP_NAMESPACE
# include <vulkan/vulkan_to_string.hpp>
#endif
#if !defined( VULKAN_HPP_NO_FROM_STRING )
# include <vulkan/vulkan_from_string.hpp>
#endif
#ifndef VULKAN_HPP_NO_EXCEPTIONS
namespace std
{
@ -15994,7 +15998,7 @@ namespace VULKAN_HPP_NAMESPACE
# elif defined( __APPLE__ )
m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
# elif defined( _WIN32 )
m_library = ::LoadLibraryA( "vulkan-1.dll" );
m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else
# error unsupported platform
# endif

7460
vulkan/vulkan_from_string.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

6
vulkan/vulkan_funcs.hpp
View File

@ -17525,7 +17525,7 @@ namespace VULKAN_HPP_NAMESPACE
# else
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
Device::acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -17547,7 +17547,7 @@ namespace VULKAN_HPP_NAMESPACE
# else
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
Device::releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -20238,7 +20238,7 @@ namespace VULKAN_HPP_NAMESPACE
# else
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );