git.patch

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bfc3a66..10b3401 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,10 +47,18 @@ add_definitions(-DVK_SPEC="${vk_spec}")
 
 if (NOT DEFINED VULKAN_HPP_PATH)
   set(VULKAN_HPP_PATH "${CMAKE_CURRENT_SOURCE_DIR}/vulkan")
+  set(VULKAN_HPP_INT_PATH "${VULKAN_HPP_PATH}/internal/")
+  set(VULKAN_HPP_INT_STRUCTS_PATH "${VULKAN_HPP_PATH}/internal/struct/")
+  set(VULKAN_HPP_INT_CMDS_PATH "${VULKAN_HPP_PATH}/internal/cmds/")
 endif()
-file(TO_NATIVE_PATH ${VULKAN_HPP_PATH}/vulkan.hpp vulkan_hpp)
-string(REPLACE "\\" "\\\\" vulkan_hpp ${vulkan_hpp})
-add_definitions(-DVULKAN_HPP_FILE="${vulkan_hpp}")
+string(REPLACE "\\" "\\\\" VULKAN_HPP_PATH ${VULKAN_HPP_PATH})
+file(MAKE_DIRECTORY ${VULKAN_HPP_INT_PATH})
+string(REPLACE "\\" "\\\\" VULKAN_HPP_INT_PATH ${VULKAN_HPP_INT_PATH})
+file(MAKE_DIRECTORY ${VULKAN_HPP_INT_STRUCTS_PATH})
+string(REPLACE "\\" "\\\\" VULKAN_HPP_INT_STRUCTS_PATH ${VULKAN_HPP_INT_STRUCTS_PATH})
+file(MAKE_DIRECTORY ${VULKAN_HPP_INT_CMDS_PATH})
+string(REPLACE "\\" "\\\\" VULKAN_HPP_INT_CMDS_PATH ${VULKAN_HPP_INT_CMDS_PATH})
+add_definitions(-DVULKAN_HPP_PATH="${VULKAN_HPP_PATH}" -DVULKAN_HPP_INT_PATH="${VULKAN_HPP_INT_PATH}" -DVULKAN_HPP_INT_STRUCTS_PATH="${VULKAN_HPP_INT_STRUCTS_PATH}" -DVULKAN_HPP_INT_CMDS_PATH="${VULKAN_HPP_INT_CMDS_PATH}")
 include_directories(${VULKAN_HPP_PATH})
 
 
diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 49be868..09c641c 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -20,6 +20,7 @@
 #include <exception>
 #include <regex>
 #include <iterator>
+#include <unordered_map>
 #include "VulkanHppGenerator.hpp"
 
 void appendArgumentCount(std::string & str, size_t vectorIndex, std::string const& vectorName, std::string const& counterName, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool singular);
@@ -2607,23 +2608,26 @@ void VulkanHppGenerator::appendHandles(std::string & str) const
   }
 }
 
-void VulkanHppGenerator::appendHandlesCommandDefintions(std::string & str) const
+std::unordered_map<std::string, std::string> VulkanHppGenerator::getHandlesCommandDefintions() const
 {
+  std::unordered_map<std::string, std::string> map;
   for (auto const& handle : m_handles)
   {
+    auto& mapString = map[handle.first.empty() ? "Vk" : handle.first];
+
     // finally the commands, that are member functions of this handle
     for (auto const& command : handle.second.commands)
     {
       std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
       std::string strippedName = startLowerCase(stripPrefix(command.first, "vk"));
 
-      str += "\n";
-      appendPlatformEnter(str, !command.second.aliases.empty(), command.second.platform);
-      appendCommand(str, "  ", commandName, command, true);
+      mapString += "\n";
+      appendPlatformEnter(mapString, !command.second.aliases.empty(), command.second.platform);
+      appendCommand(mapString, "  ", commandName, command, true);
       for (auto const& alias : command.second.aliases)
       {
-        str += "\n";
-        appendCommand(str, "  ", determineCommandName(alias, command.second.params[0].type.type), command, true);
+        mapString += "\n";
+        appendCommand(mapString, "  ", determineCommandName(alias, command.second.params[0].type.type), command, true);
       }
 
       // special handling for destroy functions
@@ -2635,21 +2639,21 @@ void VulkanHppGenerator::appendHandlesCommandDefintions(std::string & str) const
         assert(handleIt != m_handles.end());
         if (!handleIt->second.alias.empty())
         {
-          appendPlatformLeave(str, !command.second.aliases.empty(), command.second.platform);
+          appendPlatformLeave(mapString, !command.second.aliases.empty(), command.second.platform);
           platformLeft = true;
         }
 
         commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
-        str += "\n";
-        appendCommand(str, "  ", commandName, command, true);
+        mapString += "\n";
+        appendCommand(mapString, "  ", commandName, command, true);
       }
       if (!platformLeft)
       {
-        appendPlatformLeave(str, !command.second.aliases.empty(), command.second.platform);
+        appendPlatformLeave(mapString, !command.second.aliases.empty(), command.second.platform);
       }
     }
   }
-  str += "\n";
+  return map;
 }
 
 // Intended only for `enum class Result`!
@@ -3031,13 +3035,41 @@ void VulkanHppGenerator::appendStructMembers(std::string & str, std::pair<std::s
   }
 }
 
-void VulkanHppGenerator::appendStructs(std::string & str) const
+std::vector<std::pair<std::string, std::string>> VulkanHppGenerator::getStructs() const
 {
   std::set<std::string> listedStructures;
+  std::unordered_map<std::string, std::string> map;
+  std::unordered_map<std::string, std::vector<std::string>> mapInclude;
   for (auto const& structure : m_structures)
   {
-    appendStruct(str, structure, listedStructures);
+    auto name = structure.first;
+    for (size_t len = 3; len < name.length(); len++) {
+        if (!std::isupper(name.at(len)))
+            continue;
+        else {
+            if(name.length() != (len+1) && std::isdigit(name.at(len+1)))
+                len++;
+            else if (std::isdigit(name.at(len-1)) && !std::isdigit(name.at(len-2)))
+                len--;
+            name = name.substr(0, len);
+            break;
+        }
+    }
+    auto& includes = mapInclude[name];
+    for(auto& item : map)
+        if(std::find(includes.begin(), includes.end(), item.first) == includes.end())
+            includes.push_back(item.first);
+    appendStruct(map[name], structure, listedStructures);
+  }
+  std::vector<std::pair<std::string, std::string>> vtr;
+  for(auto& item : map) {
+    std::string includeString{};
+    for(auto& include : mapInclude.at(item.first))
+        includeString += "#include \"" + include + ".hpp\"\n";
+    item.second = includeString + "\nnamespace VULKAN_HPP_NAMESPACE\n{" + item.second + "} // namespace VULKAN_HPP_NAMESPACE\n";
+    vtr.push_back(item);
   }
+  return vtr;
 }
 
 void VulkanHppGenerator::appendStructSetter(std::string & str, std::string const& structureName, MemberData const& memberData) const
@@ -6522,8 +6554,7 @@ static const std::string constExpressionArrayCopy = R"(
 )";
 
   static const std::string includes = R"(
-#ifndef VULKAN_HPP
-#define VULKAN_HPP
+#pragma once
 
 #include <algorithm>
 #include <array>
@@ -6725,7 +6756,7 @@ namespace std
 
     std::string filename = (argc == 1) ? VK_SPEC : argv[1];
     std::cout << "Loading vk.xml from " << filename << std::endl;
-    std::cout << "Writing vulkan.hpp to " << VULKAN_HPP_FILE << std::endl;
+    std::cout << "Writing vulkan headers to " << VULKAN_HPP_PATH << std::endl;
 
     tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
     if (error != tinyxml2::XML_SUCCESS)
@@ -6736,61 +6767,179 @@ namespace std
 
     VulkanHppGenerator generator(doc);
 
-    std::string str;
+    std::string base, dispatch, objects, enums, exceptions_, bitmasks, forward, handles, structs, commands, dynamicDispatch;
+    
     static const size_t estimatedLength = 4 * 1024 * 1024;
-    str.reserve(estimatedLength);
-    str += generator.getVulkanLicenseHeader()
-      + includes
-      + "\n";
-    appendVersionCheck(str, generator.getVersion());
-    appendTypesafeStuff(str, generator.getTypesafeCheck());
-    str += defines
-      + "\n"
-      + "namespace VULKAN_HPP_NAMESPACE\n"
-      + "{\n"
+    base.reserve(estimatedLength);
+    dispatch.reserve(estimatedLength);
+    objects.reserve(estimatedLength);
+    enums.reserve(estimatedLength);
+    bitmasks.reserve(estimatedLength);
+    exceptions_.reserve(estimatedLength);
+    forward.reserve(estimatedLength);
+    handles.reserve(estimatedLength);
+    structs.reserve(estimatedLength);
+    commands.reserve(estimatedLength);
+    dynamicDispatch.reserve(estimatedLength);
+
+    
+    base += generator.getVulkanLicenseHeader() + includes + "\n";
+    appendVersionCheck(base, generator.getVersion());
+    appendTypesafeStuff(base, generator.getTypesafeCheck());
+    base += defines + "\nnamespace VULKAN_HPP_NAMESPACE\n{\n"
       + classArrayProxy
       + classFlags
       + classOptional
       + classStructureChain
       + classUniqueHandle;
-    generator.appendDispatchLoaderStatic(str);
-    generator.appendDispatchLoaderDefault(str);
-    str += classObjectDestroy
+    base += "} // namespace VULKAN_HPP_NAMESPACE\n";
+
+    
+    dispatch += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"base.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendDispatchLoaderDefault(dispatch);
+    generator.appendDispatchLoaderStatic(dispatch);
+    dispatch += "} // namespace VULKAN_HPP_NAMESPACE\n";
+    
+
+    objects += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"dispatch.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n"
+      + classObjectDestroy
       + classObjectFree
       + classPoolFree
       + constExpressionArrayCopy
       + "\n";
-    generator.appendBaseTypes(str);
-    generator.appendEnums(str);
-    str += typeTraits;
-    generator.appendBitmasks(str);
-    str += "} // namespace VULKAN_HPP_NAMESPACE\n"
-      + is_error_code_enum
-      + "\n"
-      + "namespace VULKAN_HPP_NAMESPACE\n"
-      + "{\n"
-      + "#ifndef VULKAN_HPP_NO_EXCEPTIONS"
-      + exceptions;
-    generator.appendResultExceptions(str);
-    generator.appendThrowExceptions(str);
-    str += "#endif\n"
-      + structResultValue;
-    generator.appendForwardDeclarations(str);
-    generator.appendHandles(str);
-    generator.appendStructs(str);
-    generator.appendHandlesCommandDefintions(str);
-    generator.appendStructureChainValidation(str);
-    generator.appendDispatchLoaderDynamic(str);
-    str += "} // namespace VULKAN_HPP_NAMESPACE\n"
-      "#endif\n";
-
-    assert(str.length() < estimatedLength);
-    cleanup(str);
-
-    std::ofstream ofs(VULKAN_HPP_FILE);
-    assert(!ofs.fail());
-    ofs << str;
-    ofs.close();
+    generator.appendBaseTypes(objects);
+    objects += "} // namespace VULKAN_HPP_NAMESPACE\n";
+    
+
+    enums += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"objects.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendEnums(enums);
+    enums += typeTraits + "\n} // namespace VULKAN_HPP_NAMESPACE\n";
+
+
+    bitmasks += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"enums.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendBitmasks(bitmasks);
+    bitmasks += "} // namespace VULKAN_HPP_NAMESPACE\n";
+    
+
+    exceptions_ += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"bitmasks.hpp\"\n\n" + is_error_code_enum + "\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n#ifndef VULKAN_HPP_NO_EXCEPTIONS" + exceptions;
+    generator.appendResultExceptions(exceptions_);
+    generator.appendThrowExceptions(exceptions_);
+    exceptions_ += "#endif\n" + structResultValue + "} // namespace VULKAN_HPP_NAMESPACE\n";
+
+    forward += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"exceptions.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendForwardDeclarations(forward);
+    forward += "} // namespace VULKAN_HPP_NAMESPACE\n";
+
+
+    handles += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"forward.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendHandles(handles);
+    handles += "} // namespace VULKAN_HPP_NAMESPACE\n";
+   
+    
+    auto genStructs = generator.getStructs();
+    structs = generator.getVulkanLicenseHeader() + "\n#pragma once\n\n";
+    
+
+    auto genCmds = generator.getHandlesCommandDefintions();
+    commands += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n";
+
+
+    dynamicDispatch += generator.getVulkanLicenseHeader() + "\n#pragma once\n\n#include \"commands.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n";
+    generator.appendStructureChainValidation(dynamicDispatch);
+    generator.appendDispatchLoaderDynamic(dynamicDispatch);
+    dynamicDispatch += "} // namespace VULKAN_HPP_NAMESPACE\n";
+
+
+    cleanup(base);
+    cleanup(objects);
+    cleanup(dispatch);
+    cleanup(structs);
+    cleanup(enums);
+    cleanup(bitmasks);
+    cleanup(exceptions_);
+    cleanup(forward);
+    cleanup(handles);
+    cleanup(commands);
+    cleanup(dynamicDispatch);
+
+    
+    std::ofstream baseStream(VULKAN_HPP_INT_PATH"/base.hpp");
+    assert(!baseStream.fail());
+    baseStream << base;
+    baseStream.close();
+
+    std::ofstream objectsStream(VULKAN_HPP_INT_PATH "/objects.hpp");
+    assert(!objectsStream.fail());
+    objectsStream << objects;
+    objectsStream.close();
+
+    std::ofstream dispatchStream(VULKAN_HPP_INT_PATH "/dispatch.hpp");
+    assert(!dispatchStream.fail());
+    dispatchStream << dispatch;
+    dispatchStream.close();
+
+    std::ofstream enumsStream(VULKAN_HPP_INT_PATH "/enums.hpp");
+    assert(!enumsStream.fail());
+    enumsStream << enums;
+    enumsStream.close();
+
+    std::ofstream bitmasksStream(VULKAN_HPP_INT_PATH "/bitmasks.hpp");
+    assert(!bitmasksStream.fail());
+    bitmasksStream << bitmasks;
+    bitmasksStream.close();
+
+    std::ofstream exceptionsStream(VULKAN_HPP_INT_PATH "/exceptions.hpp");
+    assert(!exceptionsStream.fail());
+    exceptionsStream << exceptions_;
+    exceptionsStream.close();
+
+    std::ofstream forwardStream(VULKAN_HPP_INT_PATH "/forward.hpp");
+    assert(!forwardStream.fail());
+    forwardStream << forward;
+    forwardStream.close();
+
+    std::ofstream handlesStream(VULKAN_HPP_INT_PATH "/handles.hpp");
+    assert(!handlesStream.fail());
+    handlesStream << handles;
+    handlesStream.close();
+    
+    for (auto& genStruct : genStructs) {
+      auto path = VULKAN_HPP_INT_STRUCTS_PATH + genStruct.first + ".hpp";
+      std::ofstream typeStream(VULKAN_HPP_INT_STRUCTS_PATH + genStruct.first + ".hpp");
+      cleanup(genStruct.second);
+      typeStream << generator.getVulkanLicenseHeader() << "\n#pragma once\n\n#include \"../handles.hpp\"\n" << genStruct.second;
+      typeStream.close();
+      structs += "#include \"struct/" + genStruct.first + ".hpp" + "\"\n";
+    }
+
+    std::ofstream structsStream(VULKAN_HPP_INT_PATH "/structs.hpp");
+    assert(!structsStream.fail());
+    structsStream << structs;
+    structsStream.close();
+    
+    for (auto& genCmd : genCmds) {
+      auto path = VULKAN_HPP_INT_CMDS_PATH + genCmd.first + ".hpp";
+      std::ofstream typeStream(VULKAN_HPP_INT_CMDS_PATH + genCmd.first + ".hpp");
+      cleanup(genCmd.second);
+      typeStream << generator.getVulkanLicenseHeader() << "\n#pragma once\n\n#include \"../structs.hpp\"\n\nnamespace VULKAN_HPP_NAMESPACE\n{\n" << genCmd.second << "} // namespace VULKAN_HPP_NAMESPACE\n";
+      typeStream.close();
+      commands += "#include \"cmds/" + genCmd.first + ".hpp" + "\"\n";
+    }
+
+    std::ofstream commandsStream(VULKAN_HPP_INT_PATH "/commands.hpp");
+    assert(!commandsStream.fail());
+    commandsStream << commands;
+    commandsStream.close();
+
+    std::ofstream dynamicDispatchStream(VULKAN_HPP_INT_PATH "/dynamicDispatch.hpp");
+    assert(!dynamicDispatchStream.fail());
+    dynamicDispatchStream << dynamicDispatch;
+    dynamicDispatchStream.close();
+
+    std::ofstream mainStream(VULKAN_HPP_PATH "/vulkan.hpp");
+    assert(!mainStream.fail());
+    mainStream << "#pragma once\n\n#include \"internal/dynamicDispatch.hpp\"\n";
+    mainStream.close();
   }
   catch (std::exception const& e)
   {
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index d335967..43db9f9 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -33,9 +33,9 @@ class VulkanHppGenerator
     void appendEnums(std::string & str) const;
     void appendForwardDeclarations(std::string & str) const;
     void appendHandles(std::string & str) const;
-    void appendHandlesCommandDefintions(std::string & str) const;
+    std::unordered_map<std::string, std::string> getHandlesCommandDefintions() const;
     void appendResultExceptions(std::string & str) const;
-    void appendStructs(std::string & str) const;
+    std::vector<std::pair<std::string, std::string>> getStructs() const;
     void appendStructureChainValidation(std::string & str);
     void appendThrowExceptions(std::string & str) const;
     std::string const& getTypesafeCheck() const;