atalantestudio · d-level · Nov 21, 2025 · Nov 21, 2025 · Nov 21, 2025 · Nov 21, 2025
diff --git a/.gitmodules b/.gitmodules
@@ -1,4 +1,4 @@
 [submodule "Base"]
 	path = Base
-	url = git@github.com:atalantestudio/ModuleBase
+	url = https://github.com/atalantestudio/ModuleBase
 	branch = main
diff --git a/Base b/Base
diff --git a/scroll/ConsoleLogger/ConsoleLogger.hpp b/scroll/ConsoleLogger/ConsoleLogger.hpp
@@ -3,9 +3,9 @@
 
 #pragma once
 
-#include "ConsoleEscapeCode.hpp"
-#include "Logger/Logger.hpp"
-#include "LogLevel.hpp"
+#include "scroll/ConsoleEscapeCode.hpp"
+#include "scroll/Logger/Logger.hpp"
+#include "scroll/LogLevel.hpp"
 
 namespace scroll {
 	class ConsoleLogger : public Logger {
@@ -24,9 +24,6 @@ namespace scroll {
 			template<typename Argument>
 			ConsoleLogger& operator<<(Argument&& argument);
 
-			template<>
-			ConsoleLogger& operator<<(ConsoleEscapeCode&& argument);
-
 			ConsoleLogger& padLeft(uint64 padding);
 
 			ConsoleLogger& padRight(uint64 padding);
@@ -67,4 +64,4 @@ namespace scroll {
 	};
 }
 
-#include "ConsoleLogger.ipp"
+#include "scroll/ConsoleLogger/ConsoleLogger.ipp"
diff --git a/scroll/ConsoleLogger/ConsoleLogger.ipp b/scroll/ConsoleLogger/ConsoleLogger.ipp
@@ -14,9 +14,10 @@ namespace scroll {
 	}
 
 	inline ConsoleLogger::ConsoleLogger(std::ostream& stream, LogLevel minimumLogLevel, view<char8> source) :
-		Logger(minimumLogLevel, source),
-		stream(&stream)
-	{}
+		Logger(minimumLogLevel, source)
+	{
+		setOutputStream(stream);
+	}
 
 	inline ConsoleLogger::~ConsoleLogger() {
 		if (writingEscapeCodes) {
@@ -30,6 +31,13 @@ namespace scroll {
 
 	inline void ConsoleLogger::setOutputStream(std::ostream& stream) {
 		this->stream = &stream;
+
+		#if ATL_OPERATING_SYSTEM == ATL_OPERATING_SYSTEM_WINDOWS
+			const HANDLE hConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+			ATL_ASSERT(hConsoleHandle != NULL && hConsoleHandle != INVALID_HANDLE_VALUE);
+			ATL_ASSERT(SetConsoleMode(hConsoleHandle, ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING) > 0);
+		#endif
 	}
 
 	template<typename Argument>
@@ -82,7 +90,7 @@ namespace scroll {
 		std::ostream& stream = std::cerr;
 
 		writeLogHeader(stream, source, "TRACE", ConsoleEscapeCode::BACKGROUND_COLOR_WHITE, ConsoleEscapeCode::FOREGROUND_COLOR_BLACK);
-		writeIndented(stream, format("[]\nat []:[]", format(std::forward<Argument>(argument)), file, line), getLogIndentation() - 2);
+		writeIndented(stream, format("[] (at []:[])", format(std::forward<Argument>(argument)), file, line), getLogIndentation() - 2);
 
 		stream << '\n';
 	}
@@ -96,7 +104,7 @@ namespace scroll {
 		std::ostream& stream = std::cerr;
 
 		writeLogHeader(stream, source, "TRACE", ConsoleEscapeCode::BACKGROUND_COLOR_WHITE, ConsoleEscapeCode::FOREGROUND_COLOR_BLACK);
-		writeIndented(stream, format("[]\nat []:[]", format(pattern, std::forward<Argument>(arguments)...), file, line), getLogIndentation() - 2);
+		writeIndented(stream, format("[] (at []:[])", format(pattern, std::forward<Argument>(arguments)...), file, line), getLogIndentation() - 2);
 
 		stream << '\n';
 	}
@@ -195,7 +203,7 @@ namespace scroll {
 
 		writeLogHeader(stream, source, "ERROR", ConsoleEscapeCode::BACKGROUND_COLOR_LIGHT_RED, ConsoleEscapeCode::FOREGROUND_COLOR_WHITE);
 		stream << "\033[" << ConsoleEscapeCode::FOREGROUND_COLOR_LIGHT_RED << 'm';
-		writeIndented(stream, format("[]\nat [] ([]:[])", format(std::forward<Argument>(argument)), function, file, line), getLogIndentation() - 2);
+		writeIndented(stream, format("[] (in [], at []:[])", format(std::forward<Argument>(argument)), function, file, line), getLogIndentation() - 2);
 		stream << "\033[" << ConsoleEscapeCode::RESET_FOREGROUND_COLOR << "m\n";
 	}
 
@@ -209,7 +217,7 @@ namespace scroll {
 
 		writeLogHeader(stream, source, "ERROR", ConsoleEscapeCode::BACKGROUND_COLOR_LIGHT_RED, ConsoleEscapeCode::FOREGROUND_COLOR_WHITE);
 		stream << "\033[" << ConsoleEscapeCode::FOREGROUND_COLOR_LIGHT_RED << 'm';
-		writeIndented(stream, format("[]\nat [] ([]:[])", format(pattern, std::forward<Argument>(arguments)...), function, file, line), getLogIndentation() - 2);
+		writeIndented(stream, format("[] (in [], at []:[])", format(pattern, std::forward<Argument>(arguments)...), function, file, line), getLogIndentation() - 2);
 		stream << "\033[" << ConsoleEscapeCode::RESET_FOREGROUND_COLOR << "m\n";
 	}
 }
diff --git a/scroll/Conversions.hpp b/scroll/Conversions.hpp
@@ -3,11 +3,11 @@
 
 #pragma once
 
-#include "ConsoleEscapeCode.hpp"
+#include "scroll/ConsoleEscapeCode.hpp"
 
 namespace scroll {
 	std::ostream& operator<<(std::ostream& stream, view<char8> view);
 	std::ostream& operator<<(std::ostream& stream, ConsoleEscapeCode code);
 }
 
-#include "Conversions.ipp"
+#include "scroll/Conversions.ipp"
diff --git a/scroll/FileLogger/FileLogger.hpp b/scroll/FileLogger/FileLogger.hpp
@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include "Logger/Logger.hpp"
-#include "LogLevel.hpp"
+#include "scroll/Logger/Logger.hpp"
+#include "scroll/LogLevel.hpp"
 
 namespace scroll {
 	class FileLogger : public Logger {
@@ -49,4 +49,4 @@ namespace scroll {
 	};
 }
 
-#include "FileLogger.ipp"
+#include "scroll/FileLogger/FileLogger.ipp"
diff --git a/scroll/FileLogger/FileLogger.ipp b/scroll/FileLogger/FileLogger.ipp
@@ -6,7 +6,7 @@ namespace scroll {
 		Logger(minLogLevel, source),
 		stream(stream)
 	{
-		ASSERT(stream.is_open());
+		ATL_ASSERT(stream.is_open());
 	}
 
 	template<typename Argument>
@@ -16,7 +16,7 @@ namespace scroll {
 		}
 
 		writeLogHeader("TRACE");
-		writeIndented(stream, format("[]\nat []:[]", format(std::forward<Argument>(argument)), file, line), getLogIndentation() - 4);
+		writeIndented(stream, format("[] (at []:[])", format(std::forward<Argument>(argument)), file, line), getLogIndentation() - 4);
 
 		stream << '\n';
 	}
@@ -28,7 +28,7 @@ namespace scroll {
 		}
 
 		writeLogHeader("TRACE");
-		writeIndented(stream, format("[]\nat []:[]", format(pattern, std::forward<Argument>(arguments)...), file, line), getLogIndentation() - 4);
+		writeIndented(stream, format("[] (at []:[])", format(pattern, std::forward<Argument>(arguments)...), file, line), getLogIndentation() - 4);
 
 		stream << '\n';
 	}
@@ -112,7 +112,7 @@ namespace scroll {
 		}
 
 		writeLogHeader("ERROR");
-		writeIndented(stream, format("[]\nat [] ([]:[])", format(std::forward<Argument>(argument)), function, file, line), getLogIndentation() - 4);
+		writeIndented(stream, format("[] (in [], at []:[])", format(std::forward<Argument>(argument)), function, file, line), getLogIndentation() - 4);
 
 		stream << '\n';
 	}
@@ -124,7 +124,7 @@ namespace scroll {
 		}
 
 		writeLogHeader("ERROR");
-		writeIndented(stream, format("[]\nat [] ([]:[])", format(pattern, std::forward<Argument>(arguments)...), function, file, line), getLogIndentation() - 4);
+		writeIndented(stream, format("[] (in [], at []:[])", format(pattern, std::forward<Argument>(arguments)...), function, file, line), getLogIndentation() - 4);
 
 		stream << '\n';
 	}

diff --git a/scroll/Logger/Logger.hpp b/scroll/Logger/Logger.hpp
@@ -3,10 +3,15 @@
 
 #pragma once
 
-#include "LogLevel.hpp"
+#include "scroll/LogLevel.hpp"
 
 namespace scroll {
-	class Logger {
+	template<typename T = void>
+	struct ArgumentInjectionPattern {
+		static sequence<char8> argumentInjectionPattern;
+	};
+
+	class Logger : public ArgumentInjectionPattern<> {
 		public:
 			// Returns the current argument injection pattern.
 			static view<char8> getArgumentInjectionPattern();
@@ -27,9 +32,7 @@ namespace scroll {
 			static void writeIndented(std::ostream& stream, view<char8> text, uint64 indentation);
 
 		private:
-			static sequence<char8> argumentInjectionPattern;
-
-			static constexpr uint64 TIMESTAMP_SIZE = 14;
+			static constexpr uint64 TIMESTAMP_SIZE = 15;
 			static constexpr uint64 MAX_LOG_LEVEL_NAME_SIZE = 7;
 
 		public:
@@ -48,4 +51,4 @@ namespace scroll {
 	};
 }
 
-#include "Logger.ipp"
+#include "scroll/Logger/Logger.ipp"
diff --git a/scroll/Logger/Logger.ipp b/scroll/Logger/Logger.ipp
@@ -2,13 +2,20 @@
 // Licensed under MIT.
 
 namespace scroll {
+	template<typename T>
+	sequence<char8> ArgumentInjectionPattern<T>::argumentInjectionPattern = "[]";
+
 	template<typename Argument>
 	sequence<char8> Logger::format(Argument&& argument) {
-		std::ostringstream stream;
+		static std::ostringstream stream;
 
 		stream << argument;
 
-		return stream.str().c_str();
+		const sequence<char8> formattedArgument = stream.str().c_str();
+
+		stream.str({});
+
+		return formattedArgument;
 	}
 
 	template<typename HeadArgument, typename... Argument>
@@ -23,46 +30,61 @@ namespace scroll {
 
 		sequence<char8> updatedPattern(pattern.count() - argumentInjectionPattern.count() + formattedArgument.count());
 
-		std::copy_n(&pattern[0], argumentInjectionPatternOffset, &updatedPattern[0]);
-		std::copy(formattedArgument.begin(), formattedArgument.end(), &updatedPattern[argumentInjectionPatternOffset]);
+		copy(&pattern[0], &pattern[argumentInjectionPatternOffset], &updatedPattern[0]);
+		copy(formattedArgument.begin(), formattedArgument.end(), &updatedPattern[argumentInjectionPatternOffset]);
 
 		if (argumentInjectionPatternOffset + argumentInjectionPattern.count() < pattern.count()) {
-			std::copy(&pattern[argumentInjectionPatternOffset + argumentInjectionPattern.count()], pattern.end(), &updatedPattern[argumentInjectionPatternOffset + formattedArgument.count()]);
+			copy(&pattern[argumentInjectionPatternOffset + argumentInjectionPattern.count()], pattern.end(), &updatedPattern[argumentInjectionPatternOffset + formattedArgument.count()]);
 		}
 
 		return format(updatedPattern, std::forward<Argument>(arguments)...);
 	}
 
-	inline sequence<char8> Logger::argumentInjectionPattern = "[]";
-
 	inline view<char8> Logger::getArgumentInjectionPattern() {
 		return argumentInjectionPattern;
 	}
 
 	inline void Logger::setArgumentInjectionPattern(view<char8> pattern) {
-		ASSERT(pattern.count() > 0);
+		ATL_ASSERT(pattern.count() > 0);
 
 		argumentInjectionPattern = &pattern[0];
 	}
 
 	inline sequence<char8> Logger::timestamp() {
+		static std::ostringstream usStream;
+
 		const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
-		const uint64 ms = std::chrono::duration_cast<std::chrono::milliseconds>(now - std::chrono::time_point_cast<std::chrono::seconds>(now)).count();
+		const uint64 us = std::chrono::duration_cast<std::chrono::microseconds>(now - std::chrono::time_point_cast<std::chrono::seconds>(now)).count();
 		const std::time_t time = std::chrono::system_clock::to_time_t(now);
 
-		std::tm dateTime;
+		std::tm* dateTime;
+
+		#ifdef _MSC_VER
+			std::tm _dateTime{};
 
-		localtime_s(&dateTime, &time);
+			const errno_t error = localtime_s(&_dateTime, &time);
 
-		// NOTE: std::strftime writes the null-terminating character.
+			ATL_ASSERT(error == 0);
+
+			dateTime = &_dateTime;
+		#else
+			dateTime = std::localtime(&time);
+		#endif
+
+		// Include null-terminating character.
 		sequence<char8> hmsString(9);
 
-		ASSERT(std::strftime(&hmsString[0], hmsString.count(), "%T", &dateTime) > 0);
+		const uint64 hmsCharacterCount = std::strftime(&hmsString[0], hmsString.count(), "%H:%M:%S", dateTime);
+
+		ATL_ASSERT(hmsCharacterCount > 0);
+
+		usStream << std::setw(6) << std::setfill('0') << us;
+
+		const sequence<char8> timestamp = format("[].[]", hmsString, usStream.str());
 
-		std::ostringstream msStream;
-		msStream << std::setw(3) << std::setfill('0') << ms;
+		usStream.str({});
 
-		return format("[].[]", hmsString, msStream.str());
+		return timestamp;
 	}
 
 	inline LogLevel Logger::getMinLogLevel() const {
@@ -79,7 +101,7 @@ namespace scroll {
 	{}
 
 	inline uint16 Logger::getLogIndentation() const {
-		uint16 indentation = static_cast<uint16>(TIMESTAMP_SIZE + MAX_LOG_LEVEL_NAME_SIZE + 4);
+		uint16 indentation = static_cast<uint16>(TIMESTAMP_SIZE + MAX_LOG_LEVEL_NAME_SIZE + 6);
 
 		if (source.count() > 0) {
 			indentation += static_cast<uint16>(source.count()) + 1;

diff --git a/scroll/base.hpp b/scroll/base.hpp
@@ -4,15 +4,25 @@
 #pragma once
 
 #include <chrono>
+#include <ctime>
 #include <fstream>
 #include <iomanip>
+#include <ios>
 #include <iostream>
 #include <sstream>
 
 #ifndef ATL_MODULE_BASE
 	#include "Base/Base/Base.hpp"
 #endif
 
+#if ATL_OPERATING_SYSTEM == ATL_OPERATING_SYSTEM_WINDOWS
+	#include <Windows.h>
+
+	#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+		#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+	#endif
+#endif
+
 namespace scroll {
 	using atl::uint8;
 	using atl::uint16;
@@ -23,4 +33,6 @@ namespace scroll {
 
 	using atl::sequence;
 	using atl::view;
+
+	using atl::copy;
 }
diff --git a/scroll/scroll.hpp b/scroll/scroll.hpp
@@ -3,9 +3,7 @@
 
 #pragma once
 
-#include "base.hpp"
-
-#include "Conversions.hpp"
-
-#include "ConsoleLogger/ConsoleLogger.hpp"
-#include "FileLogger/FileLogger.hpp"
+#include "scroll/base.hpp"
+#include "scroll/Conversions.hpp"
+#include "scroll/ConsoleLogger/ConsoleLogger.hpp"
+#include "scroll/FileLogger/FileLogger.hpp"
+2 −0		Base/Base.hpp
+1 −1		Base/Context.hpp
+8 −8		Base/Types/sequence.hpp
+1 −1		Base/Types/view.hpp
+14 −0		Base/Utilities.hpp
+1 −2		LICENSE