Append data at the end of the shared binary

CMakeLists.txt

@@ -52,7 +52,7 @@ foreach(dep
   add_subdirectory(external/${dep})
 endforeach()
 
-# Building SO
+# Building
 add_library(${PROJECT_NAME} SHARED
   "source/Systems/ECS/Components.cpp"
   "source/Systems/ECS/World.cpp"
@@ -63,15 +63,25 @@ add_library(${PROJECT_NAME} SHARED
 
 # Actual linking
 target_link_libraries(${PROJECT_NAME} PUBLIC
-  Corrade::Main
+    Corrade::Main
-  Corrade::Containers
+    Corrade::Containers
-  Corrade::Utility
+    Corrade::Utility
-  Corrade::PluginManager
+    Corrade::PluginManager
 )
 
 # Module stuff
 set_target_properties(${PROJECT_NAME} PROPERTIES VERSION ${PROJECT_VERSION})
 
+
+target_include_directories(${PROJECT_NAME}
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/headers>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/>
+    $<BUILD_INTERFACE:${corrade_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:include/${PROJECT_NAME}>
+    $<INSTALL_INTERFACE:include/${PROJECT_NAME}External>
+)
+
 FetchContent_GetProperties(Corrade SOURCE_DIR corrade_SOURCE_DIR)
 FetchContent_GetProperties(Corrade BINARY_DIR corrade_BINARY_DIR)
 
@@ -85,13 +95,9 @@ install(
     PATTERN "*.hpp"
 )
 
-target_include_directories(${PROJECT_NAME}
+# A way to live forever
-  PUBLIC
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/headers>
+    COMMAND printf "Dedicated to my beloved Goma, I love you. - Dora" >> $<TARGET_FILE:${PROJECT_NAME}>
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/>
-    $<BUILD_INTERFACE:${corrade_SOURCE_DIR}/src>
-    $<INSTALL_INTERFACE:include/${PROJECT_NAME}>
-    $<INSTALL_INTERFACE:include/${PROJECT_NAME}External>
 )
 
 install(
@@ -99,7 +105,14 @@ install(
   EXPORT ${PROJECT_NAME}Targets
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib
-  INCLUDES DESTINATION include
+  INCLUDES DESTINATION include/${PROJECT_NAME}
+)
+
+install(
+  TARGETS CorradeMain CorradeUtility CorradeContainers CorradePluginManager
+  LIBRARY DESTINATION lib
+  ARCHIVE DESTINATION lib
+  INCLUDES DESTINATION include/${PROJECT_NAME}External
 )
 
 install(DIRECTORY headers/ DESTINATION include/${PROJECT_NAME})

README.md

@@ -18,7 +18,9 @@ Tormaline Engine is a game engine created for C++23. [Source Code](https://git.t
 Tourmaline is by no means currently usable. The project is incredible volatile with constant changes and improvements. Please wait until a release is made.
 
 However if you cannot just help yourself you can compile a tourmaline demo by running
-g++ program.cpp -std=c++23 -lTourmaline -I/usr/local/include/TourmalineExternal -o program
+```
+g++ program.cpp -std=c++23 -lTourmaline -lCorradeUtility -lCorradePluginManager -I/usr/local/include/TourmalineExternal -o program
+```
 
 # 3rd Party Libraries Credits
 - [Corrade/Magnum](https://magnum.graphics/) - graphics middleware by Vladimír "Mosra" Vondruš.

external/Corrade/CMakeLists.txt

@@ -1,7 +1,7 @@
 include(FetchContent)
 
 # Building options
-set(CORRADE_BUILD_STATIC ON)
+set(CORRADE_BUILD_STATIC OFF)
 
 # Feature options
 set(CORRADE_WITH_MAIN ON)

headers/Concepts.hpp

@@ -11,6 +11,8 @@
 #define GUARD_TOURMALINE_CONCEPTS_H
 #include <concepts>
 #include <functional>
+#include <tuple>
+#include <type_traits>
 
 namespace Tourmaline::Concepts {
 template <typename T>
@@ -30,5 +32,29 @@ template <typename Base, typename Type1, typename Type2>
   requires Either<Base, Type1, Type2>
 using OppositeOf = _opposite_of<Base, Type1, Type2>::type;
 
+// heavily inspired by
+// https://github.com/aminroosta/sqlite_modern_cpp/blob/master/hdr/sqlite_modern_cpp/utility/function_traits.h
+template <typename> struct FunctionTraits;
+template <typename Function>
+struct FunctionTraits
+    : public FunctionTraits<
+          decltype(&std::remove_reference_t<Function>::operator())> {};
+
+template <typename Return, typename Class, typename... Arguments>
+struct FunctionTraits<Return (Class::*)(Arguments...) const>
+    : FunctionTraits<Return (*)(Arguments...)> {};
+template <typename Return, typename Class, typename... Arguments>
+struct FunctionTraits<Return (Class::*)(Arguments...)>
+    : FunctionTraits<Return (*)(Arguments...)> {};
+
+template <typename Return, typename... Arguments>
+struct FunctionTraits<Return (*)(Arguments...)> {
+  using returnType = Return;
+  using arguments = std::tuple<Arguments...>;
+
+  template <std::size_t index>
+  using argument = std::tuple_element_t<index, arguments>;
+  static constexpr std::size_t argumentCount = sizeof...(Arguments);
+};
 } // namespace Tourmaline::Concepts
 #endif

headers/Containers/DualkeyMap.hpp

@@ -13,8 +13,9 @@
 #include "ContainerOptions.hpp"
 #include "Hashmap.hpp"
 
+#include "Corrade/Containers/Array.h"
+
 #include <algorithm>
-#include <array>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
@@ -33,14 +34,14 @@ template <Concepts::Hashable AKey, Concepts::Hashable BKey, typename Value,
 class DualkeyMap {
 public:
   // Return Types
-  template <typename OppositeKey, std::size_t keyCount>
+  template <typename OppositeKey>
     requires Concepts::Either<OppositeKey, AKey, BKey>
   struct MultiQueryResult {
     // Having to use pointers here over references was not fun
     // but it was for greater good
     const OppositeKey *oppositeKey;
+    Corrade::Containers::Array<Value *> valueQueryResults;
     std::size_t howManyFound = 1;
-    std::array<Value *, keyCount> valueQueryResults;
   };
 
   using QueryResult =
@@ -205,19 +206,19 @@ public:
   }
 
   template <typename Key,
-            typename OppositeKey = Concepts::OppositeOf<Key, AKey, BKey>,
+            typename OppositeKey = Concepts::OppositeOf<Key, AKey, BKey>>
-            std::size_t keyCount>
     requires Concepts::Either<Key, AKey, BKey>
   [[nodiscard("Discarding a very expensive query!")]]
-  std::vector<MultiQueryResult<OppositeKey, keyCount>>
+  std::vector<MultiQueryResult<OppositeKey>>
-  QueryWithAll(const Key (&keys)[keyCount]) {
+  QueryWithAll(const Corrade::Containers::Array<Key> &keys) {
-    std::vector<MultiQueryResult<OppositeKey, keyCount>> queryResult =
+    std::vector<MultiQueryResult<OppositeKey>> queryResult =
         queryWithMany<Key>(keys);
-    std::erase_if(
+
-        queryResult,
+    std::erase_if(queryResult,
-        [](const MultiQueryResult<OppositeKey, keyCount> &queryRecord) {
+                  [keyCount = keys.size()](
-          return queryRecord.howManyFound != keyCount;
+                      const MultiQueryResult<OppositeKey> &queryRecord) {
-        });
+                    return queryRecord.howManyFound != keyCount;
+                  });
     return queryResult;
   }
 
@@ -269,14 +270,14 @@ private:
 
   // Interal querying
   template <typename Key,
-            typename OppositeKey = Concepts::OppositeOf<Key, AKey, BKey>,
+            typename OppositeKey = Concepts::OppositeOf<Key, AKey, BKey>>
-            std::size_t keyCount>
+  inline std::vector<MultiQueryResult<OppositeKey>>
-  inline std::vector<MultiQueryResult<OppositeKey, keyCount>>
+  queryWithMany(const Corrade::Containers::Array<Key> &keys) {
-  queryWithMany(const Key (&keys)[keyCount]) {
     constexpr bool searchingInFirstKey = std::is_same_v<Key, AKey>;
+    std::size_t keyCount = keys.size();
 
     // I really can't wait for C++26 contracts
-    if constexpr (keyCount == 0) {
+    if (keyCount == 0) {
       Systems::Logging::Log("Failed to Query! QueryWithAll require at least 2 "
                             "key to be given, zero was given! Terminating",
                             "Dualkey Map",
@@ -284,7 +285,7 @@ private:
     }
 
     // Hoping this never ever gets triggered :sigh:
-    if constexpr (keyCount == 1) {
+    if (keyCount == 1) {
       Systems::Logging::Log("QueryWithAll should not be used for single key "
                             "entry! Please use Query for this instead.",
                             "Dualkey Map", Systems::Logging::LogLevel::Error);
@@ -292,7 +293,7 @@ private:
 
     // While we don't necessary need the hashes,
     // it just helps us tremendously benefit from short circuit checks
-    std::array<std::size_t, keyCount> keyHashes;
+    Corrade::Containers::Array<std::size_t> keyHashes{keyCount};
     for (uint64_t index = 0; index < keyCount; index++) {
       keyHashes[index] = std::hash<Key>{}(keys[index]);
     }
@@ -301,7 +302,7 @@ private:
     Key *keyToCompare;
     OppositeKey *oppositeKey;
 
-    Containers::Hashmap<OppositeKey, MultiQueryResult<OppositeKey, keyCount>,
+    Containers::Hashmap<OppositeKey, MultiQueryResult<OppositeKey>,
                         {8.0f, 0.01f, 2.5f, 2048, 8}> // Aggressive hashmap :o
         queryResults;
 
@@ -334,8 +335,9 @@ private:
           }
 
           queryResults
-              .Insert(*oppositeKey,
+              .Insert(
-                      MultiQueryResult<OppositeKey, keyCount>(oppositeKey))
+                  *oppositeKey,
+                  {oppositeKey, Corrade::Containers::Array<Value *>{keyCount}})
               .valueQueryResults[index] = &hash->value;
         }
       }

headers/Containers/Hashmap.hpp

@@ -34,8 +34,7 @@ public:
     if (!storage[keyHashPosition].empty()) {
       // Throws
       Systems::Logging::Log("Trying to insert the same key twice! Throwing...",
-                            "Hashmap", Systems::Logging::LogLevel::Error,
+                            "Hashmap", Systems::Logging::Error, Has(key));
-                            Has(key));
     } else {
       storage[keyHashPosition].reserve(Options.reservedBucketSpace);
     }
@@ -51,7 +50,7 @@ public:
 
     // Throws
     Systems::Logging::Log("Trying to remove a non-existant key! Throwing...",
-                          "Hashmap", Systems::Logging::LogLevel::Error,
+                          "Hashmap", Systems::Logging::Error,
                           storage[keyHashPosition].empty());
     std::erase_if(storage[keyHashPosition],
                   [keyHash, &key](const hashStorage &hash) {
@@ -90,8 +89,7 @@ public:
 
     Systems::Logging::Log(
         "Trying to access a non-existant bucket for a key! Throwing...",
-        "Hashmap", Systems::Logging::LogLevel::Error,
+        "Hashmap", Systems::Logging::Error, storage[keyHashPosition].empty());
-        storage[keyHashPosition].empty());
 
     for (hashStorage &hash : storage[keyHashPosition]) {
       if (hash.hash == keyHash && hash.key == key) {
@@ -100,7 +98,8 @@ public:
     }
 
     Systems::Logging::Log("Trying to access a non-existant key! Throwing...",
-                          "Hashmap", Systems::Logging::LogLevel::Error);
+                          "Hashmap", Systems::Logging::Error);
+    throw;
   }
 
   [[nodiscard("Discarding an expensive operation!")]]
@@ -160,8 +159,8 @@ private:
 
     // Repopulate and cleanup
     for (bucket &entry : oldStorage) {
-      for (const hashStorage &hash : entry) {
+      for (hashStorage &hash : entry) {
-        Insert(hash.key, hash.value);
+        Insert(std::move(hash.key), std::move(hash.value));
       }
 
       entry.clear();

headers/Systems/ECS.hpp

@@ -10,64 +10,60 @@
 #ifndef GUARD_TOURMALINE_ECS_H
 #define GUARD_TOURMALINE_ECS_H
 #include <any>
-#include <format>
 #include <typeindex>
 
 #include "../Containers/DualkeyMap.hpp"
+#include "../Containers/Hashmap.hpp"
 #include "../Types.hpp"
 #include "ECS/BuiltinComponents.hpp"
 #include "Logging.hpp"
 
 namespace Tourmaline::Systems::ECS {
 using Entity = Tourmaline::Type::UUID;
-class World;
+using System = Tourmaline::Type::UUID;
 
 class World {
 public:
+  World() {}
   // ====== World controls ======
   void Step();
 
   // ========  Entities  ========
   [[nodiscard]]
   Entity CreateEntity();
+  [[nodiscard("Pointless call of EntityExists")]]
   bool EntityExists(const Entity &entity) noexcept;
-  [[nodiscard("It is not guaranteed that an entity can always be destroyed, "
-              "please make sure by checking the returned bool")]]
   bool DestroyEntity(Entity entity);
 
   // ======== Components ========
-  template <isAComponent component, typename... Args>
+  template <isAComponent Component, typename... ComponentArgs>
-  component &AddComponent(const Entity &entity,
+  Component &AddComponent(const Entity &entity, ComponentArgs &&...args) {
-                          Args &&...constructionArguments) {
+    auto newComponent = entityComponentMap.Insert(entity, typeid(Component),
-    auto newComponent = entityComponentMap.Insert(
+                                                  Component(args...));
-        entity, typeid(component), component(constructionArguments...));
 
-    return std::any_cast<component &>(std::get<2>(newComponent));
+    return std::any_cast<Component &>(std::get<2>(newComponent));
   }
 
-  template <isAComponent component>
+  template <isAComponent Component>
-  [[nodiscard("Discarding an expensive operation's result!")]]
+  [[nodiscard("Pointless call of GetComponent")]]
-  component &GetComponent(const Entity &entity) {
+  Component &GetComponent(const Entity &entity) {
-    auto result = entityComponentMap.Query(entity, typeid(component));
+    auto result = entityComponentMap.Query(entity, typeid(Component));
     if (result.empty()) {
-      Logging::Log(std::format("Entity {} does not have component {}!",
+      Logging::LogFormatted("Entity {} does not have component {}!",
-                               entity.asString(), typeid(component).name()),
+                            "ECS/GetComponent", Logging::LogLevel::Error,
-                   "ECS/GetComponent", Logging::LogLevel::Error);
+                            entity.asString(), typeid(Component).name());
     }
-    return std::any_cast<component &>(result.begin()->second);
+    return std::any_cast<Component &>(result.begin()->second);
   }
 
-  template <isAComponent component>
+  template <isAComponent Component>
-  [[nodiscard("Discarding an expensive operation's result!")]]
+  [[nodiscard("Pointless call of HasComponent")]]
   bool HasComponent(const Entity &entity) {
-    return entityComponentMap.Query(entity, typeid(component)).size();
+    return entityComponentMap.Query(entity, typeid(Component)).size();
   }
 
-  template <isAComponent component>
+  template <isAComponent Component> bool RemoveComponent(const Entity &entity) {
-  [[nodiscard("It is not guaranteed that a component can always be removed, "
+    return entityComponentMap.Remove(entity, typeid(Component));
-              "please make sure by checking the returned bool")]]
-  bool RemoveComponent(const Entity &entity) {
-    return entityComponentMap.Remove(entity, typeid(component));
   }
 
   // Copying is not allowed since the ECS world is meant to be
@@ -76,8 +72,11 @@ public:
   World &operator=(const World &) = delete;
 
 private:
-  Tourmaline::Containers::DualkeyMap<Entity, std::type_index, std::any>
+  using systemFunction =
+      std::function<void(const Entity &, std::span<std::any *>)>;
+  Containers::DualkeyMap<Entity, std::type_index, std::any>
       entityComponentMap{};
+  Containers::Hashmap<System, systemFunction> registeredSystems{};
 
   // ======== Life-cycle ========
   void preSystems();

headers/Systems/ECS/BuiltinComponents.hpp

@@ -24,7 +24,7 @@ concept isAComponent = std::derived_from<T, ECS::Component>;
 namespace Tourmaline::Systems::Components {
 // Builtin
 struct Base : public ECS::Component {
-  Base() {}
+  double x = 0, y = 0, z = 0;
 };
 } // namespace Tourmaline::Systems::Components
 #endif

headers/Systems/Logging.hpp

@@ -8,31 +8,36 @@
  */
 #ifndef GUARD_TOURMALINE_LOGGING_H
 #define GUARD_TOURMALINE_LOGGING_H
-#include <array>
+
+#include "Corrade/Containers/String.h"
+#include "Corrade/Containers/StringView.h"
+#include "Corrade/Utility/Format.h"
+
 #include <fstream>
-#include <string_view>
 
 namespace Tourmaline::Systems {
 class Logging {
 public:
-  enum class LogLevel {
+  enum LogLevel { Critical, Error, Warning, Info, Debug, Trace };
-    Critical = 0,
-    Error = 1,
-    Warning = 2,
-    Info = 3,
-    Debug = 4,
-    Trace = 5
-  };
 
-  static void LogToFile(std::string File = "");
+  static void LogToFile(Corrade::Containers::String File = "");
-  static void Log(std::string_view message,
+  static void Log(Corrade::Containers::StringView message,
-                  std::string_view position = "Unknown",
+                  Corrade::Containers::StringView position = "Unknown",
                   LogLevel severity = LogLevel::Info, bool assertion = true);
 
+  template <class... Args>
+  static void LogFormatted(const char *format, const char *position,
+                           LogLevel severity, const Args &...args) {
+    static Corrade::Containers::String output{Corrade::ValueInit, 4096};
+    std::size_t size = Corrade::Utility::formatInto(output, format, args...);
+    Log(Corrade::Containers::StringView{output.begin(), size}, position,
+        severity);
+  }
+
 private:
   static std::fstream File;
-  static std::array<std::pair<const std::string, const std::string>, 6>
+  static const char *LogLevelToColour[Trace + 1];
-      LogLevelToString;
+  static const char *LogLevelToString[Trace + 1];
 };
 } // namespace Tourmaline::Systems
 #endif

headers/Systems/Random.hpp

@@ -10,7 +10,7 @@
 #ifndef GUARD_TOURMALINE_RANDOM_H
 #define GUARD_TOURMALINE_RANDOM_H
 #include "../Types.hpp"
-#include <TourmalineExternal/random/xoshiro.h>
+#include "TourmalineExternal/random/xoshiro.h"
 
 #include <type_traits>
 

headers/Types.hpp

@@ -10,7 +10,9 @@
 #ifndef GUARD_TOURMALINE_TYPES_H
 #define GUARD_TOURMALINE_TYPES_H
 
+#include "Corrade/Containers/String.h"
 #include "TourmalineExternal/random/xoshiro.h"
+
 #include <cstdint>
 #include <functional>
 #include <string>
@@ -19,7 +21,7 @@ namespace Tourmaline::Type {
 class UUID {
 public:
   [[nodiscard]]
-  std::string asString() const;
+  Corrade::Containers::String asString() const;
   bool operator==(const UUID &rhs) const;
 
   UUID(uint64_t firstHalf, uint64_t secondHalf);

source/Systems/ECS/Components.cpp

@@ -7,7 +7,7 @@
  * obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#include "../../../headers/Systems/ECS.hpp"
+#include "Systems/ECS.hpp"
-#include "../../../headers/Systems/ECS/BuiltinComponents.hpp"
+#include "Systems/ECS/BuiltinComponents.hpp"
 
 // Empty until future use

source/Systems/ECS/World.cpp

@@ -7,9 +7,9 @@
  * obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#include "../../../headers/Systems/ECS.hpp"
+#include "Systems/ECS.hpp"
-#include "../../../headers/Systems/ECS/BuiltinComponents.hpp"
+#include "Systems/ECS/BuiltinComponents.hpp"
-#include "../../../headers/Systems/Random.hpp"
+#include "Systems/Random.hpp"
 
 using namespace Tourmaline::Systems;
 using namespace ECS;

source/Systems/Logging.cpp

@@ -7,7 +7,12 @@
  * obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#include "../../headers/Systems/Logging.hpp"
+#include "Systems/Logging.hpp"
+
+#include "Corrade/Containers/String.h"
+#include "Corrade/Containers/StringView.h"
+#include "Corrade/Tags.h"
+#include "Corrade/Utility/Format.h"
 
 #include <cerrno>
 #include <chrono>
@@ -16,63 +21,63 @@
 #include <exception>
 #include <format>
 #include <fstream>
-#include <iterator>
 #include <print>
 #include <stdexcept>
-#include <string>
 #include <string_view>
-#include <utility>
 
 using namespace Tourmaline::Systems;
+using namespace Corrade::Containers;
+using namespace Corrade::Utility;
 
 // This is what happens when it takes you 50 years to implement
 // reflections to a language
-std::array<std::pair<const std::string, const std::string>, 6>
+const char *Logging::LogLevelToColour[Logging::Trace + 1]{
-    Logging::LogLevelToString{std::pair{"Critical", "[0;31m"},
+    "[0;31m", "[0;91m", "[0;33m", "[0;37m", "[0;92m", "[0;36m"};
-                              {"Error", "[0;91m"},
+const char *Logging::LogLevelToString[Logging::Trace + 1]{
-                              {"Warning", "[0;33m"},
+    "Critical", "Error", "Warning", "Info", "Debug", "Trace"};
-                              {"Info", "[0;37m"},
-                              {"Debug", "[0;92m"},
-                              {"Trace", "[0;36m"}};
 std::fstream Logging::File;
 
-void Logging::LogToFile(std::string File) {
+void Logging::LogToFile(String File) {
   if (File == "") {
     const auto now = std::chrono::system_clock::now();
-    File = std::format("Tourmaline-{:%Y-%j}.txt", now);
+    std::chrono::year_month_day ymd{std::chrono::floor<std::chrono::days>(now)};
+    File = String{Corrade::ValueInit, 128};
+    formatInto(File, "Tourmaline-{}-{}-{}.txt", static_cast<int>(ymd.year()),
+               static_cast<unsigned>(ymd.month()),
+               static_cast<unsigned>(ymd.day()));
   }
-  Logging::File.open(File, std::fstream::out);
+  Logging::File.open(File.data(), std::fstream::out);
 
   if (Logging::File.fail()) {
-    throw std::runtime_error("FAILED! Could not open or create the file: " +
+    String error =
-                             File + "!\n" + strerror(errno));
+        format("FAILED! Could not open or create the file: {}! Error: {}", File,
+               strerror(errno));
+    throw std::runtime_error(error.data());
   }
 }
 
-void Logging::Log(std::string_view message, std::string_view position,
+void Logging::Log(StringView message, StringView position,
                   Logging::LogLevel severity, bool assertion) {
-  if (assertion) [[likely]] {
+  if (assertion) {
-    static std::string
+    static String output{Corrade::ValueInit,
-        output; // This is done to stop allocations per std::format
+                         4096}; // This is done to stop allocations
-    const auto &loglevelData =
+    std::size_t formattedSize = formatInto(
-        Logging::LogLevelToString[static_cast<size_t>(severity)];
+        output, "[{}@{}] {}\n", LogLevelToString[severity], position, message);
-    std::format_to(std::back_inserter(output), "[{}@{}] {}\n",
-                   loglevelData.first, position, message);
 
-    std::print("\033{} {}\033[0m", loglevelData.second, output);
+    std::print(
+        "\033{} {}\033[0m", LogLevelToColour[severity],
+        std::string_view{output.begin(), output.begin() + formattedSize});
     if (Logging::File.is_open()) {
-      Logging::File.write(output.c_str(), output.size());
+      Logging::File.write(output.data(), formattedSize);
       Logging::File.flush(); // Terrible but necessary sadly
     }
 
     if (severity == Logging::LogLevel::Error) {
-      throw std::runtime_error(output);
+      throw std::runtime_error(output.data());
     }
 
     if (severity == Logging::LogLevel::Critical) {
       std::terminate();
     }
-
-    output.clear();
   }
 }

source/Systems/Random.cpp

@@ -6,7 +6,8 @@
  * v. 2.0. If a copy of the MPL was not distributed with this file, You can
  * obtain one at http://mozilla.org/MPL/2.0/.
  */
-#include "../../headers/Systems/Random.hpp"
+
+#include "Systems/Random.hpp"
 
 #include <bit>
 #include <cstdint>

source/Types/UUID.cpp

@@ -7,17 +7,19 @@
  * obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#include "../../headers/Types.hpp"
+#include "Corrade/Utility/Format.h"
+#include "Types.hpp"
 
 #include <charconv>
 #include <cstdint>
 #include <cstring>
-#include <format>
 #include <string>
 
 using namespace Tourmaline::Type;
-std::string UUID::asString() const {
+using namespace Corrade::Containers;
-  return std::format("{:016X}{:016X}", firstHalf, secondHalf);
+using namespace Corrade::Utility;
+String UUID::asString() const {
+  return format("{:.16X}{:.16X}", firstHalf, secondHalf);
 }
 
 bool UUID::operator==(const UUID &rhs) const {