Adapt to core modules

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.25)
+cmake_minimum_required(VERSION 3.28)
 project(gamingcore CXX)
 
 add_subdirectory(glfw SYSTEM)
@@ -59,11 +59,48 @@ target_link_libraries(gamingcore
     PRIVATE core glfw vulkan ${LINK_OPTIONS}
 )
 target_include_directories(gamingcore SYSTEM
-    PUBLIC ${CMAKE_INSTALL_PREFIX}/include
     PUBLIC enet/include
     PUBLIC stb
     PUBLIC glfw/include
 )
+target_sources(gamingcore PUBLIC
+    FILE_SET CXX_MODULES
+    BASE_DIRS ${CMAKE_INSTALL_PREFIX}/modules
+    FILES
+        "${CMAKE_INSTALL_PREFIX}/modules/Array.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/AlignedData.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/ArrayList.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/BitArray.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Box.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Buffer.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Clock.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Color.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Components.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/File.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Frustum.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/HashMap.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/HashedString.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/List.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Logger.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Math.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Matrix.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Meta.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Plane.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Quaternion.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Queue.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Random.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/ReadLine.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Terminal.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Test.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Thread.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/ToString.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Types.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Unicode.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/UniquePointer.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Utility.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/Vector.cppm"
+        "${CMAKE_INSTALL_PREFIX}/modules/View.cppm"
+)
 target_link_directories(gamingcore
     PUBLIC ${CMAKE_INSTALL_PREFIX}/lib
 )

include/core/Image.hpp

@@ -1,8 +1,8 @@
 #ifndef GAMINGCORE_IMAGE_HPP
 #define GAMINGCORE_IMAGE_HPP
 
-#include <core/List.hpp>
-#include <core/Types.hpp>
+import Core.List;
+import Core.Types;
 
 namespace Core {
     struct Image8 {

include/core/Network.hpp

@@ -1,9 +1,9 @@
 #ifndef GAMINGCORE_NETWORK_HPP
 #define GAMINGCORE_NETWORK_HPP
 
-#include <core/Buffer.hpp>
-#include <core/Types.hpp>
-#include <core/UniquePointer.hpp>
+import Core.Buffer;
+import Core.Types;
+import Core.UniquePointer;
 
 namespace Core {
     enum class PacketSendMode { RELIABLE, SEQUENCED, UNSEQUENCED };

include/core/VulkanBase.hpp

@@ -1,10 +1,10 @@
 #ifndef GAMINGCORE_VULKAN_BASE_HPP
 #define GAMINGCORE_VULKAN_BASE_HPP
 
-#include <core/Array.hpp>
-#include <core/List.hpp>
-#include <core/Types.hpp>
-#include <core/Utility.hpp>
+import Core.Array;
+import Core.List;
+import Core.Types;
+import Core.Utility;
 
 #define GLFW_INCLUDE_VULKAN
 #include <GLFW/glfw3.h>

include/core/VulkanUtility.hpp

@@ -1,17 +1,17 @@
 #ifndef GAMINGCORE_VULKAN_UTILITY_HPP
 #define GAMINGCORE_VULKAN_UTILITY_HPP
 
-#include <core/Logger.hpp>
-
 #include <vulkan/vulkan.h>
 
+import Core.Logger;
+
 namespace Core::Vulkan {
     const char* getResultString(VkResult r);
 }
 
-#define VK_REPORT(level, format, ...)                                          \
-    REPORT(                                                                    \
-        Core::LogLevel::level, "Vulkan | " format __VA_OPT__(, ) __VA_ARGS__);
+#define VK_REPORT(level, format, ...)                                         \
+    Core::report(                                                             \
+        Core::LogLevel::level, "Vulkan | " format __VA_OPT__(, ) __VA_ARGS__)
 #define VK_REPORT_ERROR(...) VK_REPORT(ERROR, __VA_ARGS__)
 #define VK_REPORT_WARNING(...) VK_REPORT(WARNING, __VA_ARGS__)
 #define VK_CHECK(r, a)                                                     \

include/core/VulkanWrapper.hpp

@@ -1,14 +1,14 @@
 #ifndef GAMINGCORE_VULKAN_WRAPPER_HPP
 #define GAMINGCORE_VULKAN_WRAPPER_HPP
 
-#include <core/List.hpp>
-#include <core/Meta.hpp>
-#include <core/Types.hpp>
-
 #include <vulkan/vulkan.h>
 
 #include "core/VulkanBase.hpp"
 
+import Core.List;
+import Core.Meta;
+import Core.Types;
+
 namespace Core::Vulkan {
     bool init();
     void render();

include/core/WindowManager.hpp

@@ -1,8 +1,8 @@
 #ifndef GAMINGCORE_WINDOW_MANAGER_HPP
 #define GAMINGCORE_WINDOW_MANAGER_HPP
 
-#include <core/Types.hpp>
-#include <core/Vector.hpp>
+import Core.Types;
+import Core.Vector;
 
 namespace Core::Window {
     using RunHandler = bool (*)(void* data);

src/Image.cpp

@@ -1,10 +1,11 @@
 #include "core/Image.hpp"
 
 #include <cerrno>
-#include <core/Logger.hpp>
-#include <core/Utility.hpp>
 #include <cstring>
 
+import Core.Logger;
+import Core.Utility;
+
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpragmas"
 #pragma GCC diagnostic ignored "-Wunknown-warning-option"
@@ -19,7 +20,7 @@
 #pragma GCC diagnostic pop
 
 static void reportError(const char* path) {
-    REPORT(
+    Core::report(
         Core::LogLevel::ERROR, "Cannot read image '#': #", path,
         strerror(errno));
 }

src/Network.cpp

@@ -2,15 +2,19 @@
 
 #define ENET_IMPLEMENTATION
 #include <cassert>
-#include <core/HashMap.hpp>
-#include <core/Logger.hpp>
-#include <core/Utility.hpp>
 #include <cstring>
 
 #include <enet.h>
 
 #include "ErrorSimulator.hpp"
 
+import Core.HashMap;
+import Core.Logger;
+import Core.Utility;
+import Core.Types;
+import Core.Math;
+import Core.Buffer;
+
 using Core::Client;
 using Core::InPacket;
 using Core::OutPacket;
@@ -136,8 +140,9 @@ void OutPacket::writeI16(i16 i) {
 }
 
 void OutPacket::writeI32(i32 i) {
-    writeU32(static_cast<u32>(
-        static_cast<i64>(i) + static_cast<i64>(2'147'483'648)));
+    writeU32(
+        static_cast<u32>(
+            static_cast<i64>(i) + static_cast<i64>(2'147'483'648)));
 }
 
 void OutPacket::writeFloat(float f) {
@@ -203,16 +208,16 @@ Client::~Client() {
 
 bool Client::start() {
     if(data->client != nullptr) {
-        REPORT(LogLevel::WARNING, "Client already started");
+        Core::report(LogLevel::WARNING, "Client already started");
         return true;
     } else if(addENet()) {
-        REPORT(LogLevel::ERROR, "Client cannot initialize enet");
+        Core::report(LogLevel::ERROR, "Client cannot initialize enet");
         return true;
     }
     data->client = FAIL(enet_host_create(nullptr, 1, 2, 0, 0), nullptr);
     if(data->client == nullptr) {
         stop();
-        REPORT(LogLevel::ERROR, "Cannot create enet client host");
+        Core::report(LogLevel::ERROR, "Cannot create enet client host");
         return true;
     }
     return false;
@@ -237,10 +242,10 @@ void Client::stop() {
 
 bool Client::connect(const char* server, Port port, int timeoutTicks) {
     if(data->client == nullptr) {
-        REPORT(LogLevel::WARNING, "Client not started");
+        Core::report(LogLevel::WARNING, "Client not started");
         return true;
     } else if(data->connection != nullptr) {
-        REPORT(LogLevel::WARNING, "Connection already exists");
+        Core::report(LogLevel::WARNING, "Connection already exists");
         return true;
     }
 
@@ -251,7 +256,7 @@ bool Client::connect(const char* server, Port port, int timeoutTicks) {
     data->connection =
         FAIL(enet_host_connect(data->client, &address, 3, 0), nullptr);
     if(data->connection == nullptr) {
-        REPORT(LogLevel::ERROR, "Cannot create connection");
+        Core::report(LogLevel::ERROR, "Cannot create connection");
         return true;
     }
     data->connectTicks = 1;
@@ -387,13 +392,13 @@ Server::~Server() {
 
 bool Server::start(Port port, size_t maxClients) {
     if(maxClients <= 0) {
-        REPORT(LogLevel::ERROR, "Invalid max client amount");
+        Core::report(LogLevel::ERROR, "Invalid max client amount");
         return true;
     } else if(data->server != nullptr) {
-        REPORT(LogLevel::WARNING, "Server already started");
+        Core::report(LogLevel::WARNING, "Server already started");
         return true;
     } else if(addENet()) {
-        REPORT(LogLevel::ERROR, "Server cannot initialize enet");
+        Core::report(LogLevel::ERROR, "Server cannot initialize enet");
         return true;
     }
 
@@ -402,7 +407,7 @@ bool Server::start(Port port, size_t maxClients) {
         FAIL(enet_host_create(&address, maxClients, 3, 0, 0), nullptr);
     if(data->server == nullptr) {
         stop();
-        REPORT(LogLevel::ERROR, "Cannot create enet server host");
+        Core::report(LogLevel::ERROR, "Cannot create enet server host");
         return true;
     }
     return false;

src/VulkanBase.cpp

@@ -1,10 +1,14 @@
 #include "core/VulkanBase.hpp"
 
-#include <core/List.hpp>
-#include <core/Logger.hpp>
+#include <cstring>
 
 #include "GLFW.hpp"
 
+import Core.List;
+import Core.Logger;
+import Core.Types;
+import Core.Array;
+
 using Core::Vulkan::Base;
 
 #define GET_FUNCTION(name) (reinterpret_cast<PFN_##name>(getFunction(#name)))

src/VulkanWrapper.cpp

@@ -1,12 +1,20 @@
 #include "core/VulkanWrapper.hpp"
 
-#include <core/File.hpp>
-#include <core/UniquePointer.hpp>
+#include <cstring>
 
 #include "GLFW.hpp"
 #include "core/VulkanBase.hpp"
 #include "core/WindowManager.hpp"
 
+import Core.File;
+import Core.UniquePointer;
+import Core.List;
+import Core.Logger;
+import Core.Types;
+import Core.Math;
+import Core.Array;
+import Core.Vector;
+
 namespace Vulkan = Core::Vulkan;
 using Core::List;
 using Core::Vulkan::VertexBuffer;
@@ -109,7 +117,7 @@ static u32 getSwapImageCount(const VkSurfaceCapabilitiesKHR* caps) {
 
 bool Swapchain::init(Data& d) {
     Swapchain::~Swapchain();
-    VkSurfaceCapabilitiesKHR caps = {0};
+    VkSurfaceCapabilitiesKHR caps = {};
     if(d.base.getSurfaceCapabilities(caps)) {
         return true;
     }
@@ -574,31 +582,31 @@ struct VulkanDummy {
     }
 
     bool getSwapchainSize(VkExtent2D* size) {
-        VkSurfaceCapabilitiesKHR c = {0};
+        VkSurfaceCapabilitiesKHR c = {};
         if(base.getSurfaceCapabilities(c)) {
             return true;
         }
         if(c.currentExtent.width != 0xFFFF'FFFFu &&
            c.currentExtent.height != 0xFFFF'FFFFu) {
             *size = c.currentExtent;
-            LOG_INFO("Swapchain size: #x#", size->width, size->height);
+            Core::logInfo("Swapchain size: #x#", size->width, size->height);
             return false;
         }
         int w = 0;
         int h = 0;
         glfwGetFramebufferSize(Core::Window::get(), &w, &h);
         if(w <= 0 || h <= 0) {
-            LOG_ERROR("Could not get framebuffer size");
+            Core::logError("Could not get framebuffer size");
             return true;
         }
-        LOG_INFO("Framebuffer size: #x#", w, h);
+        Core::logInfo("Framebuffer size: #x#", w, h);
         size->width = Core::clamp(
             static_cast<u32>(w), c.minImageExtent.width,
             c.maxImageExtent.width);
         size->height = Core::clamp(
             static_cast<u32>(h), c.minImageExtent.height,
             c.maxImageExtent.height);
-        LOG_INFO("Swapchain size: #x#", size->width, size->height);
+        Core::logInfo("Swapchain size: #x#", size->width, size->height);
         return false;
     }
 
@@ -608,7 +616,7 @@ struct VulkanDummy {
             .surfaceFormat = baseData.surfaceFormat,
             .presentMode = baseData.presentMode};
         if(getSwapchainSize(&d.size)) {
-            LOG_ERROR("Could not retrieve any swapchain size");
+            Core::logError("Could not retrieve any swapchain size");
             return true;
         }
         swapchainSize = d.size;
@@ -628,16 +636,16 @@ struct VulkanDummy {
         data.add(baseData.graphicsFamily, 1.0f);
         if(!same) {
             data.add(baseData.presentFamily, 1.0f);
-        };
+        }
         List<const char*> extensions;
         extensions.add(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
         if(base.initDevice(data, extensions)) {
             return true;
         } else if(graphicsQueue.init(base, baseData.graphicsFamily)) {
-            LOG_ERROR("Cannot get device graphics queue");
+            Core::logError("Cannot get device graphics queue");
             return true;
         } else if(presentQueue.init(base, baseData.presentFamily)) {
-            LOG_ERROR("Cannot get device present queue");
+            Core::logError("Cannot get device present queue");
             return true;
         }
         return false;
@@ -647,7 +655,7 @@ struct VulkanDummy {
         int points = 0;
         VkPhysicalDeviceProperties p;
         b.getPhysicalDeviceProperties(p);
-        LOG_INFO("Checking '#'", p.deviceName);
+        Core::logInfo("Checking '#'", p.deviceName);
         switch(p.deviceType) {
             case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: points += 100; break;
             case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: points += 50; break;
@@ -656,53 +664,53 @@ struct VulkanDummy {
         }
         d.graphicsFamily = b.findQueueFamily(VK_QUEUE_GRAPHICS_BIT);
         if(d.graphicsFamily == Vulkan::INVALID_QUEUE_FAMILY) {
-            LOG_INFO("> ... has no graphics family");
+            Core::logInfo("> ... has no graphics family");
             points = -1000;
         }
         d.presentFamily = b.findSurfaceQueueFamily();
         if(d.presentFamily == Vulkan::INVALID_QUEUE_FAMILY) {
-            LOG_INFO("> ... has no present family");
+            Core::logInfo("> ... has no present family");
             points = -1000;
         }
         if(!b.hasExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
-            LOG_INFO("> ... has no swapchain support");
+            Core::logInfo("> ... has no swapchain support");
             points = -1000;
         }
         if(b.findSurfaceFormat(d.surfaceFormat, getSurfaceFormatPoints)) {
-            LOG_INFO("> ... has no matching surface format");
+            Core::logInfo("> ... has no matching surface format");
             points = -1000;
         } else {
             points += getSurfaceFormatPoints(d.surfaceFormat);
         }
         if(b.findSurfacePresentMode(
                d.presentMode, getSurfacePresentModePoints)) {
-            LOG_INFO("> ... has no matching present mode");
+            Core::logInfo("> ... has no matching present mode");
             points = -1000;
         } else {
             points += getSurfacePresentModePoints(d.presentMode);
         }
-        LOG_INFO("> Final points: #", points);
+        Core::logInfo("> Final points: #", points);
         return points;
     }
 
     bool initPhysicalDevice() {
-        LOG_INFO("Searching for physical devices ...");
+        Core::logInfo("Searching for physical devices ...");
         if(base.findPhysicalDevice(baseData, getDevicePoints)) {
-            LOG_ERROR("No matching physical device was found");
+            Core::logError("No matching physical device was found");
             return true;
         }
         VkPhysicalDeviceProperties p;
         base.getPhysicalDeviceProperties(p);
-        LOG_INFO("Best Device: #", p.deviceName);
+        Core::logInfo("Best Device: #", p.deviceName);
         return false;
     }
 
     bool initSwapchainImages() {
         if(images.init(swapchain, baseData.surfaceFormat.format)) {
-            LOG_ERROR("Could not get swapchain images");
+            Core::logError("Could not get swapchain images");
             return true;
         }
-        LOG_INFO("Found # images", images.images.getLength());
+        Core::logInfo("Found # images", images.images.getLength());
         return false;
     }
 
@@ -771,7 +779,7 @@ struct VulkanDummy {
     }
 
     bool recreateSwapchain() {
-        LOG_INFO("Recreate swapchain");
+        Core::logInfo("Recreate swapchain");
         base.waitForIdle();
         if(initSwapchain() || initSwapchainImages() || initFramebuffers()) {
             return true;

src/WindowManager.cpp

@@ -1,17 +1,23 @@
 #include "core/WindowManager.hpp"
 
-#include <climits>
-#include <core/ArrayList.hpp>
-#include <core/Clock.hpp>
-#include <core/Logger.hpp>
-#include <core/Meta.hpp>
-#include <core/Unicode.hpp>
-#include <core/Utility.hpp>
 #include <cstdio>
 
+#include <limits.h>
+
 #include "GLFW.hpp"
 #include "core/VulkanWrapper.hpp"
 
+import Core.ArrayList;
+import Core.Clock;
+import Core.Logger;
+import Core.Meta;
+import Core.Unicode;
+import Core.Utility;
+import Core.Array;
+import Core.Vector;
+import Core.Types;
+import Core.Math;
+
 namespace Window = Core::Window;
 using Core::Array;
 
@@ -129,7 +135,7 @@ static void onMouseMove(GLFWwindow*, double x, double y) {
 
 static bool openWindowI(const Window::Options& o) {
     if(!glfwInit()) {
-        REPORT(Core::LogLevel::ERROR, "could not initialize GLFW");
+        Core::report(Core::LogLevel::ERROR, "could not initialize GLFW");
         return true;
     }
 
@@ -143,7 +149,7 @@ static bool openWindowI(const Window::Options& o) {
     GLFWmonitor* m = o.fullscreen ? glfwGetPrimaryMonitor() : nullptr;
     window = glfwCreateWindow(o.size[0], o.size[1], o.name, m, nullptr);
     if(window == nullptr) {
-        REPORT(Core::LogLevel::ERROR, "could not create window");
+        Core::report(Core::LogLevel::ERROR, "could not create window");
         return true;
     }
     size = o.size;
@@ -375,12 +381,12 @@ const char* Window::getInputString() {
     for(u32 c : input) {
         UTF8 u = convertUnicodeToUTF8(c);
         for(size_t i = 0; i < u.length; i++) {
-            convertedInput.put(u.data[i]);
+            convertedInput.put(static_cast<char>(u.data[i]));
         }
     }
-    if(convertedInput.put(0) == nullptr) {
+    if(convertedInput.put('\0') == nullptr) {
         convertedInput.removeLast();
-        convertedInput.put(0);
+        convertedInput.put('\0');
     }
     return convertedInput.begin();
 }

tasks_settings

@@ -0,0 +1,2 @@
+compiler=clang++
+run=test

test/Main.cpp

@@ -1,15 +1,18 @@
 #include <clocale>
-#include <core/Logger.hpp>
-#include <core/Utility.hpp>
 #include <cstdio>
 #include <cstring>
+#include <source_location>
 
 #include "Tests.hpp"
 
+import Core.Logger;
+import Core.Utility;
+import Core.Test;
+
 static void reportHandler(
-    Core::LogLevel, const char*, int, void*, const char* message) {
+    Core::LogLevel, const std::source_location&, void*, const char* message) {
     if(useReport) {
-        LOG_ERROR(message);
+        Core::logError(message);
     }
 }
 
@@ -21,7 +24,7 @@ int main(int argAmount, char** args) {
     setlocale(LC_ALL, "en_US.utf8");
     Core::setReportHandler(reportHandler, nullptr);
     if(argAmount < 2) {
-        LOG_ERROR("missing mode");
+        Core::logError("missing mode");
         return 0;
     } else if(strcmp("test", args[1]) == 0) {
         testImageReader("test/resources");

test/Tests.hpp

@@ -1,7 +1,7 @@
 #ifndef GAMINGCORE_TESTS_HPP
 #define GAMINGCORE_TESTS_HPP
 
-#include <core/Test.hpp>
+import Core.Test;
 
 inline bool useReport = true;
 void testImageReader(const char* path);

test/modules/ImageTests.cpp

@@ -1,5 +1,5 @@
-#include <core/Logger.hpp>
-#include <cstdio>
+import Core.Logger;
+import Core.ToString;
 
 #include "../Tests.hpp"
 #include "core/Image.hpp"
@@ -9,13 +9,13 @@ static void testReadPNG8(
     char fullPath[512];
     Core::formatBuffer(fullPath, sizeof(fullPath), "#/#.png", path, name);
     Core::Image8 i;
-    TEST(width == 0, i.read(fullPath));
+    Core::test(width == 0, i.read(fullPath));
     if(width != 0) {
-        TEST_TRUE(i.data.getLength() > 0);
+        Core::testTrue(i.data.getLength() > 0);
     }
-    TEST(width, i.width);
-    TEST(height, i.height);
-    TEST(channels, i.channels);
+    Core::test(width, i.width);
+    Core::test(height, i.height);
+    Core::test(channels, i.channels);
 }
 
 static void testReadPNG16(
@@ -23,13 +23,13 @@ static void testReadPNG16(
     char fullPath[512];
     Core::formatBuffer(fullPath, sizeof(fullPath), "#/#.png", path, name);
     Core::Image16 i;
-    TEST(width == 0, i.read(fullPath));
+    Core::test(width == 0, i.read(fullPath));
     if(width != 0) {
-        TEST_TRUE(i.data.getLength() > 0);
+        Core::testTrue(i.data.getLength() > 0);
     }
-    TEST(width, i.width);
-    TEST(height, i.height);
-    TEST(channels, i.channels);
+    Core::test(width, i.width);
+    Core::test(height, i.height);
+    Core::test(channels, i.channels);
 }
 
 void testImageReader(const char* path) {

test/modules/NetworkTests.cpp

@@ -1,27 +1,30 @@
-#include <core/Clock.hpp>
-#include <core/Logger.hpp>
-#include <core/Utility.hpp>
 #include <cstring>
 
 #include "../Tests.hpp"
 #include "../src/ErrorSimulator.hpp"
 #include "core/Network.hpp"
 
+import Core.Clock;
+import Core.Logger;
+import Core.Utility;
+import Core.Test;
+import Core.Types;
+
 using Core::Client;
 using Core::InPacket;
 using Core::OutPacket;
 using Core::Server;
 
-#define TEST_READ(Type, type, value)  \
-    {                                 \
-        type u;                       \
-        TEST_FALSE(in.read##Type(u)); \
-        TEST_TRUE(u == value);        \
+#define TEST_READ(Type, type, value)       \
+    {                                      \
+        type u;                            \
+        Core::testFalse(in.read##Type(u)); \
+        Core::testTrue(u == value);        \
     }
-#define TEST_READ_FAIL(Type, type)   \
-    {                                \
-        type u;                      \
-        TEST_TRUE(in.read##Type(u)); \
+#define TEST_READ_FAIL(Type, type)        \
+    {                                     \
+        type u;                           \
+        Core::testTrue(in.read##Type(u)); \
     }
 
 static void testWriteRead() {
@@ -50,12 +53,12 @@ static void testWriteRead() {
     TEST_READ(I32, i32, 100'430'199)
     TEST_READ(I32, i32, -534'534)
     float f;
-    TEST_FALSE(in.readFloat(f));
-    TEST_FLOAT(64564.5346f, f, 0.00001f);
+    Core::testFalse(in.readFloat(f));
+    Core::testFloat(64564.5346f, f, 0.00001f);
     char buffer[256];
     size_t n = in.readString(buffer, sizeof(buffer));
-    TEST(14, n);
-    TEST_STRING(s, buffer);
+    Core::test(14, n);
+    Core::testString(s, buffer);
 
     TEST_READ_FAIL(U8, u8)
     TEST_READ_FAIL(U16, u16)
@@ -64,8 +67,8 @@ static void testWriteRead() {
     TEST_READ_FAIL(I16, i16)
     TEST_READ_FAIL(I32, i32)
     TEST_READ_FAIL(Float, float)
-    TEST(0, in.readString(nullptr, 0));
-    TEST(0, in.readString(buffer, sizeof(buffer)));
+    Core::test(0, in.readString(nullptr, 0));
+    Core::test(0, in.readString(buffer, sizeof(buffer)));
 }
 
 static void testTooShortBuffer() {
@@ -76,12 +79,12 @@ static void testTooShortBuffer() {
     InPacket in(out.data.getData(), out.data.getLength());
     char buffer[8];
     size_t n = in.readString(buffer, sizeof(buffer));
-    TEST(14, n);
-    TEST_STRING("This is", buffer);
+    Core::test(14, n);
+    Core::testString("This is", buffer);
     char buffer2[6];
     size_t n2 = in.readString(buffer2, sizeof(buffer2));
-    TEST(10, n2);
-    TEST_STRING("Well ", buffer2);
+    Core::test(10, n2);
+    Core::testString("Well ", buffer2);
 }
 
 struct PacketTest {
@@ -97,8 +100,8 @@ static void testBinaryData() {
     InPacket in(out.data.getData(), out.data.getLength());
 
     PacketTest inData;
-    TEST_FALSE(in.read(&inData, sizeof(inData)));
-    TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);
+    Core::testFalse(in.read(&inData, sizeof(inData)));
+    Core::testTrue(memcmp(&inData, &data, sizeof(inData)) == 0);
 }
 
 static void testShortString() {
@@ -110,8 +113,8 @@ static void testShortString() {
 
     char buffer[256];
     size_t n = in.readString(buffer, sizeof(buffer));
-    TEST(200, n);
-    TEST_STRING("", buffer);
+    Core::test(200, n);
+    Core::testString("", buffer);
 }
 
 using BoolFunction = bool (*)(void*);
@@ -156,17 +159,17 @@ static void onServerDisconnect(Server&, Core::ClientHandle) {
 }
 
 static void onServerPacket(Server& s, Core::ClientHandle client, InPacket& in) {
-    TEST_FALSE(in.readU8(data1));
-    TEST_FALSE(in.readU16(data2));
-    TEST_FALSE(in.readU32(data3));
-    TEST_FALSE(in.readI8(data4));
-    TEST_FALSE(in.readI16(data5));
-    TEST_FALSE(in.readI32(data6));
-    TEST_FALSE(in.readI8(data7));
-    TEST_FALSE(in.readI16(data8));
-    TEST_FALSE(in.readI32(data9));
-    TEST(9, in.readString(data10, sizeof(data10)));
-    TEST_FALSE(in.readFloat(data11));
+    Core::testFalse(in.readU8(data1));
+    Core::testFalse(in.readU16(data2));
+    Core::testFalse(in.readU32(data3));
+    Core::testFalse(in.readI8(data4));
+    Core::testFalse(in.readI16(data5));
+    Core::testFalse(in.readI32(data6));
+    Core::testFalse(in.readI8(data7));
+    Core::testFalse(in.readI16(data8));
+    Core::testFalse(in.readI32(data9));
+    Core::test(9, in.readString(data10, sizeof(data10)));
+    Core::testFalse(in.readFloat(data11));
 
     OutPacket out;
     if(packageCounter == 0) {
@@ -221,19 +224,19 @@ static void testConnect(Core::PacketSendMode mode) {
     c.setDisconnectHandler(onClientDisconnect);
     c.setPacketHandler(onClientPacket);
 
-    if(!TEST_FALSE(s.start(54'321, 5))) {
+    if(!Core::testFalse(s.start(54'321, 5))) {
         return;
-    } else if(!TEST_FALSE(c.start())) {
+    } else if(!Core::testFalse(c.start())) {
         return;
-    } else if(!TEST_FALSE(c.connect("127.0.0.1", 54'321, 90))) {
+    } else if(!Core::testFalse(c.connect("127.0.0.1", 54'321, 90))) {
         return;
     }
-    TEST_FALSE(c.isConnected());
-    TEST_TRUE(c.isConnecting());
+    Core::testFalse(c.isConnected());
+    Core::testTrue(c.isConnecting());
     tickUntilConnected(s, c);
-    TEST_TRUE(clientConnected);
-    TEST_TRUE(c.isConnected());
-    TEST_FALSE(c.isConnecting());
+    Core::testTrue(clientConnected);
+    Core::testTrue(c.isConnected());
+    Core::testFalse(c.isConnecting());
 
     OutPacket out;
     out.writeU8(0xF1);
@@ -251,29 +254,29 @@ static void testConnect(Core::PacketSendMode mode) {
     c.sendPacket(out, mode);
 
     tick(s, c, [](void*) { return !clientPackage || !serverConnected; }, &c);
-    TEST_TRUE(clientPackage);
-    TEST_TRUE(serverConnected);
-
-    TEST(0xF1, data1);
-    TEST(0xF123, data2);
-    TEST(0xF123'4567, data3);
-    TEST(-0x71, data4);
-    TEST(-0x7123, data5);
-    TEST(-0x7123'4567, data6);
-    TEST(0x71, data7);
-    TEST(0x7123, data8);
-    TEST(0x7123'4567, data9);
-    TEST_STRING(st, data10);
-    TEST_FLOAT(252345.983f, data11, 0.01f);
+    Core::testTrue(clientPackage);
+    Core::testTrue(serverConnected);
+
+    Core::test(0xF1, data1);
+    Core::test(0xF123, data2);
+    Core::test(0xF123'4567, data3);
+    Core::test(-0x71, data4);
+    Core::test(-0x7123, data5);
+    Core::test(-0x7123'4567, data6);
+    Core::test(0x71, data7);
+    Core::test(0x7123, data8);
+    Core::test(0x7123'4567, data9);
+    Core::testString(st, data10);
+    Core::testFloat(252345.983f, data11, 0.01f);
 
     c.disconnect(90);
-    TEST_FALSE(c.isConnected());
-    TEST_FALSE(c.isConnecting());
+    Core::testFalse(c.isConnected());
+    Core::testFalse(c.isConnecting());
     tick(
         s, c, [](void*) { return !clientDisconnected || !serverDisconnect; },
         &c);
-    TEST_TRUE(clientDisconnected);
-    TEST_TRUE(serverDisconnect);
+    Core::testTrue(clientDisconnected);
+    Core::testTrue(serverDisconnect);
 
     c.stop();
     s.stop();
@@ -290,19 +293,19 @@ static void testDisconnect() {
     Client c;
     c.resetHandler();
     c.setDisconnectHandler(testStopDisconnect);
-    if(!TEST_FALSE(c.start())) {
+    if(!Core::testFalse(c.start())) {
         return;
-    } else if(!TEST_FALSE(c.connect("127.0.0.1", 54'321, 90))) {
+    } else if(!Core::testFalse(c.connect("127.0.0.1", 54'321, 90))) {
         return;
     }
-    TEST_FALSE(c.isConnected());
-    TEST_TRUE(c.isConnecting());
+    Core::testFalse(c.isConnected());
+    Core::testTrue(c.isConnecting());
     c.disconnect(50);
     Server s;
     tick(s, c, [](void*) { return !disconnected; }, &c);
-    TEST_FALSE(c.isConnected());
-    TEST_FALSE(c.isConnecting());
-    TEST_TRUE(disconnected);
+    Core::testFalse(c.isConnected());
+    Core::testFalse(c.isConnecting());
+    Core::testTrue(disconnected);
     c.stop();
 }
 
@@ -311,30 +314,30 @@ static void testStop() {
     Client c;
     c.resetHandler();
     c.setDisconnectHandler(testStopDisconnect);
-    if(!TEST_FALSE(c.start())) {
+    if(!Core::testFalse(c.start())) {
         return;
-    } else if(!TEST_FALSE(c.connect("127.0.0.1", 54'321, 90))) {
+    } else if(!Core::testFalse(c.connect("127.0.0.1", 54'321, 90))) {
         return;
     }
-    TEST_FALSE(c.isConnected());
-    TEST_TRUE(c.isConnecting());
+    Core::testFalse(c.isConnected());
+    Core::testTrue(c.isConnecting());
     c.stop();
-    TEST_FALSE(c.isConnected());
-    TEST_FALSE(c.isConnecting());
-    TEST_TRUE(disconnected);
+    Core::testFalse(c.isConnected());
+    Core::testFalse(c.isConnecting());
+    Core::testTrue(disconnected);
 }
 
 static void testClientStartFails() {
     Client c;
-    TEST_FALSE(c.start());
+    Core::testFalse(c.start());
     useReport = false;
-    TEST_TRUE(c.start());
+    Core::testTrue(c.start());
     c.stop();
 #ifdef ERROR_SIMULATOR
     failCounter = 0;
-    TEST_TRUE(c.start());
+    Core::testTrue(c.start());
     failCounter = 1;
-    TEST_TRUE(c.start());
+    Core::testTrue(c.start());
     failCounter = -1;
 #endif
     useReport = true;
@@ -344,15 +347,15 @@ static void testClientConnectionFails() {
     Client c;
     c.resetHandler();
     useReport = false;
-    TEST_TRUE(c.connect("", 54'321, 100));
-    TEST_FALSE(c.start());
+    Core::testTrue(c.connect("", 54'321, 100));
+    Core::testFalse(c.start());
 #ifdef ERROR_SIMULATOR
     failCounter = 0;
-    TEST_TRUE(c.connect("", 54'321, 100));
+    Core::testTrue(c.connect("", 54'321, 100));
     failCounter = -1;
 #endif
-    TEST_FALSE(c.connect("", 54'321, 100));
-    TEST_TRUE(c.connect("", 54'321, 100));
+    Core::testFalse(c.connect("", 54'321, 100));
+    Core::testTrue(c.connect("", 54'321, 100));
     useReport = true;
     for(int i = 0; i < 100; i++) {
         c.tick();
@@ -371,16 +374,16 @@ static void testInvalidClientAccess() {
 static void testServerStartFails() {
     useReport = false;
     Server s;
-    TEST_TRUE(s.start(54'321, 0));
+    Core::testTrue(s.start(54'321, 0));
 #ifdef ERROR_SIMULATOR
     failCounter = 0;
-    TEST_TRUE(s.start(54'321, 5));
+    Core::testTrue(s.start(54'321, 5));
     failCounter = 1;
-    TEST_TRUE(s.start(54'321, 5));
+    Core::testTrue(s.start(54'321, 5));
     failCounter = -1;
 #endif
-    TEST_FALSE(s.start(54'321, 5));
-    TEST_TRUE(s.start(54'321, 5));
+    Core::testFalse(s.start(54'321, 5));
+    Core::testTrue(s.start(54'321, 5));
     useReport = true;
     s.stop();
 }
@@ -389,12 +392,12 @@ static void testServerClosesOnConnected() {
     Server s;
     Client c;
     clientDisconnected = false;
-    TEST_FALSE(s.start(54'321, 5));
-    TEST_FALSE(c.start());
+    Core::testFalse(s.start(54'321, 5));
+    Core::testFalse(c.start());
     c.setDisconnectHandler(onClientDisconnect);
-    TEST_FALSE(c.connect("127.0.0.1", 54'321, 50));
+    Core::testFalse(c.connect("127.0.0.1", 54'321, 50));
     tickUntilConnected(s, c);
-    TEST_TRUE(c.isConnected());
+    Core::testTrue(c.isConnected());
     s.stop();
 
     c.setTimeout(500, 500, 500);
@@ -402,8 +405,8 @@ static void testServerClosesOnConnected() {
         c.tick();
         Core::Clock::sleepMillis(10);
     }
-    TEST_FALSE(c.isConnected());
-    TEST_TRUE(clientDisconnected);
+    Core::testFalse(c.isConnected());
+    Core::testTrue(clientDisconnected);
     c.stop();
 }
 
@@ -417,13 +420,13 @@ static void testServerDisconnectsClient() {
     clientDisconnected = false;
     Server s;
     Client c;
-    TEST_FALSE(s.start(54'321, 5));
-    TEST_FALSE(c.start());
+    Core::testFalse(s.start(54'321, 5));
+    Core::testFalse(c.start());
     c.setDisconnectHandler(onClientDisconnect);
     s.setConnectHandler(onConnectSetClient);
-    TEST_FALSE(c.connect("127.0.0.1", 54'321, 50));
+    Core::testFalse(c.connect("127.0.0.1", 54'321, 50));
     tickUntilConnected(s, c);
-    TEST_TRUE(c.isConnected());
+    Core::testTrue(c.isConnected());
 
     s.disconnectClient(clientId);
 
@@ -432,8 +435,8 @@ static void testServerDisconnectsClient() {
         s.tick();
         Core::Clock::sleepMillis(10);
     }
-    TEST_FALSE(c.isConnected());
-    TEST_TRUE(clientDisconnected);
+    Core::testFalse(c.isConnected());
+    Core::testTrue(clientDisconnected);
     c.stop();
     s.stop();
 }
@@ -446,13 +449,13 @@ static void testClientClosesOnConnected() {
     serverDisconnect = false;
     Server s;
     Client c;
-    TEST_FALSE(s.start(54'321, 5));
-    TEST_FALSE(c.start());
+    Core::testFalse(s.start(54'321, 5));
+    Core::testFalse(c.start());
     s.setDisconnectHandler(onServerDisconnect);
     s.setConnectHandler(onConnectSetTimeout);
-    TEST_FALSE(c.connect("127.0.0.1", 54'321, 50));
+    Core::testFalse(c.connect("127.0.0.1", 54'321, 50));
     tickUntilConnected(s, c);
-    TEST_TRUE(c.isConnected());
+    Core::testTrue(c.isConnected());
 #ifdef ERROR_SIMULATOR
     failCounter = 0;
 #endif
@@ -464,7 +467,7 @@ static void testClientClosesOnConnected() {
         s.tick();
         Core::Clock::sleepMillis(10);
     }
-    TEST_TRUE(serverDisconnect);
+    Core::testTrue(serverDisconnect);
     s.stop();
 }
 
@@ -482,11 +485,11 @@ static void testDummyCallbacks() {
     Client c;
     c.resetHandler();
     s.resetHandler();
-    TEST_FALSE(s.start(54'321, 5));
-    TEST_FALSE(c.start());
-    TEST_FALSE(c.connect("127.0.0.1", 54'321, 50));
+    Core::testFalse(s.start(54'321, 5));
+    Core::testFalse(c.start());
+    Core::testFalse(c.connect("127.0.0.1", 54'321, 50));
     tickUntilConnected(s, c);
-    TEST_TRUE(c.isConnected());
+    Core::testTrue(c.isConnected());
     OutPacket out;
     s.sendPacketBroadcast(out, Core::PacketSendMode::RELIABLE);
     c.sendPacket(out, Core::PacketSendMode::RELIABLE);

test/modules/WindowManagerTests.cpp

@@ -1,11 +1,15 @@
-#include <core/Logger.hpp>
 #include <cstdio>
+#include <source_location>
 
 #include <GLFW/glfw3.h>
 
 #include "../Tests.hpp"
 #include "core/WindowManager.hpp"
 
+import Core.Logger;
+import Core.Terminal;
+import Core.Vector;
+
 namespace W = Core::Window;
 
 static W::Button closeButton = 0;
@@ -18,7 +22,7 @@ static bool isRunning(void*) {
 
 static void tick(void*) {
     if(!W::isInputEnabled()) {
-        LOG_INFO(
+        Core::logInfo(
             "TPS: #\nFPS: #\n", W::getTicksPerSecond(),
             W::getFramesPerSecond());
         printf(
@@ -31,7 +35,7 @@ static void tick(void*) {
             W::getButtonName(testButton), W::isButtonDown(testButton),
             W::getButtonDownTime(testButton), W::wasButtonReleased(testButton));
         Core::Vector2 mouse = W::getLastMousePosition();
-        LOG_INFO("Mouse: # #\n", mouse[0], mouse[1]);
+        Core::logInfo("Mouse: # #\n", mouse[0], mouse[1]);
     }
     if(W::getButtonDownTime(textButton) == 1) {
         if(W::isInputEnabled()) {
@@ -50,8 +54,10 @@ static void render(void*, float) {
 }
 
 static void printReport(
-    Core::LogLevel l, const char* file, int line, void*, const char* message) {
-    printLog(l, file, line, TERMINAL_RED, "#", message);
+    Core::LogLevel l, const std::source_location& sl, void*,
+    const char* message) {
+    Core::log(
+        l, Core::Terminal::FG_RED, Core::FormatLocation("#", sl), message);
 }
 
 void testWindow() {