Moved from_string functions and the mappings to an inl file so they don't horribly slow down the compilation on every file.

VulkanHppGenerator.cpp

@@ -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,58 @@ ${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 <optional>
+#include <string_view>
+#include <vulkan/${api}_enums.hpp>
+
+namespace VULKAN_HPP_NAMESPACE
+{
+template<typename TEnum>
+extern std::optional<TEnum> from_string(std::string_view);
+} // namespace VULKAN_HPP_NAMESPACE
+#endif
+)";
+
+  std::string str = replaceWithMap( vulkanHandlesHppTemplate,
+                                    { { "api", m_api },
+                                      { "licenseHeader", m_vulkanLicenseHeader } } );
+
+  writeToFile( str, vulkan_from_string_hpp );
+}
+
+void VulkanHppGenerator::generateFromStringInlFile() const
+{
+std::string const vulkan_from_string_inl = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_from_string.inl";
+std::cout << "VulkanHppGenerator: Generating " << vulkan_from_string_inl << "..." << std::endl;
+
+std::string const vulkanHandlesInlTemplate = R"(${licenseHeader}
+
+#include <unordered_map>
+#include <vulkan/${api}_from_string.hpp>
+
+namespace VULKAN_HPP_NAMESPACE
+{
+${enumsFromString}
+} // namespace VULKAN_HPP_NAMESPACE
+)";
+
+std::string str = replaceWithMap( vulkanHandlesInlTemplate,
+{ { "api", m_api },
+{ "enumsFromString", generateEnumsFromString() },
+{ "licenseHeader", m_vulkanLicenseHeader } } );
+
+writeToFile( str, vulkan_from_string_inl );
+}
+
 void VulkanHppGenerator::generateCppModuleFile() const
 {
   std::string const vulkan_cppm = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".cppm";
@@ -6790,6 +6846,166 @@ ${functionBody}
                          { { "argument", enumData.second.values.empty() ? "" : " value" }, { "enumName", enumName }, { "functionBody", functionBody } } );
 }
 
+std::string VulkanHppGenerator::generateEnumsFromString() const
+{
+  const std::string enumsFromStringTemplate = R"(
+  //=========================
+  //=== ENUMs from_string ===
+  //=========================
+
+struct EnumFromStringMap
+{
+${enumsFromStringStorage}
+};
+static 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}Entries.find(value);
+    if (it != enumFromStringMap.${enumName}Entries.end())
+    {
+        return it->second;
+    }
+    return std::nullopt;
+)x";
+
+    functionBody = replaceWithMap( functionBodyTemplate, { { "enumName", enumName } } );
+  }
+
+  const std::string enumFromStringTemplate = R"(
+  template<>
+  std::optional<${enumName}> from_string<${enumName}>( std::string_view ${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_view, ${enumName}> ${enumName}Entries =
+  {
+${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 +15926,8 @@ int main( int argc, char ** argv )
     generator.generateStaticAssertionsHppFile();
     generator.generateStructsHppFile();
     generator.generateToStringHppFile();
+    generator.generateFromStringHppFile();
+    generator.generateFromStringInlFile();
     generator.generateCppModuleFile();
 
 #if !defined( CLANG_FORMAT_EXECUTABLE )

VulkanHppGenerator.hpp

@@ -101,6 +101,8 @@ public:
   void generateStaticAssertionsHppFile() const;
   void generateStructsHppFile() const;
   void generateToStringHppFile() const;
+  void generateFromStringHppFile() const;
+  void generateFromStringInlFile() const;
   void generateCppModuleFile() const;
   void prepareRAIIHandles();
   void prepareVulkanFuncs();
@@ -701,6 +703,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;

vulkan/vulkan.hpp

@@ -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

vulkan/vulkan_from_string.hpp

@@ -0,0 +1,20 @@
+// Copyright 2015-2023 The Khronos Group Inc.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+
+// This header is generated from the Khronos Vulkan XML API Registry.
+
+#ifndef VULKAN_FROM_STRING_HPP
+#define VULKAN_FROM_STRING_HPP
+
+#include <optional>
+#include <string_view>
+#include <vulkan/vulkan_enums.hpp>
+
+namespace VULKAN_HPP_NAMESPACE
+{
+  template <typename TEnum>
+  extern std::optional<TEnum> from_string( std::string_view );
+}  // namespace VULKAN_HPP_NAMESPACE
+#endif

vulkan/vulkan_funcs.hpp

@@ -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 );