Added logging functionality

Author: Mute124

.gitignore

@@ -366,6 +366,7 @@ lib
 bin
 build
 out
+temp
 
 .vscode
 *.lock

CMakeLists.txt

@@ -150,6 +150,7 @@ endif()
 find_package(eventpp REQUIRED)
 find_package(SDL2 REQUIRED CONFIG)
 find_package(rmlui REQUIRED)
+find_package(fmt REQUIRED)
 
 set(DOUBLE_PRECISION OFF)
 set(GENERATE_DEBUG_SYMBOLS OFF)

conanfile.txt

@@ -12,7 +12,18 @@
 #include <memory>
 #include <mutex>
 
+#include <Common.h>
+#include <modding/ScriptingAPI.h>
+#include <renderer/Renderer.h>
+#include <renderer/WindowDecorations.h>
+#include <conf/Config.h>
+
+#include <project.h>
+#include <raylib.h>
+#include <thread>
 
+#include <utils/MiscUtils.h>
+#include <dbg/Logging.h>
 namespace Techstorm::Application {
 
 /*	class GameThread : public Singleton<GameThread> {
@@ -138,6 +149,7 @@ namespace Techstorm::Application {
 
 	class FrameManager : public Singleton<FrameManager> {
 	public:
+
 		float sFrameTime = 0.0f; // This is provided by the main thread. This is read only and should only be set by the main thread
 		volatile bool sIsWaitingForOthers = false; // This is read only and should only be set by the main thread
 		volatile bool sExit = false;
@@ -157,7 +169,9 @@ namespace Techstorm::Application {
 			while (sIsWaitingForOthers && !sExit) {
 				std::this_thread::sleep_for(std::chrono::milliseconds(1));
 			}
-			std::cout << "Update thread started\n";
+
+			Log("Update thread started");
+
 			while (!sExit) {
 
 				userProject->preObjectUpdate();
@@ -183,7 +197,8 @@ namespace Techstorm::Application {
 			while (sIsWaitingForOthers && !sExit) {
 				std::this_thread::sleep_for(std::chrono::milliseconds(1));
 			}
-			std::cout << "Worker thread started\n";
+			Log("Worker thread started");
+
 			while (!sExit) {
 				// This is here because it reduces CPU consumption
 				std::this_thread::yield();
@@ -211,19 +226,26 @@ namespace Techstorm::Application {
 			while (sIsWaitingForOthers && !sExit) {
 
 				if (isWorkerWaiting && isUpdateWaiting) {
-					std::cout << "All threads are ready\n";
+
+
+					Log("All threads are ready");
+
 					sIsWaitingForOthers = false;
 					break;
 				}
 				else {
-					std::cout << "Waiting for threads...\n";
+					Log("Waiting for threads...", ELogLevel::TRACE);
 					std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
 				}
 
 
 			}
 		}
+
+		void killThreads() {
+			sExit = true;
+		}
 	private:
 
 
@@ -234,6 +256,9 @@ namespace Techstorm::Application {
 		//ThreadStatus renderThreadStatus;
 	};
 
+
+
+
 	using GameThreadInfo = std::unordered_map<std::string, bool>;
 
 	GameThreadInfo CalculateGameThreadInfo(GameSettings& gameSettings);

multisink.txt

@@ -1,20 +1,17 @@
-#include <Common.h>
-#include <modding/ScriptingAPI.h>
-#include <renderer/Renderer.h>
-#include <renderer/WindowDecorations.h>
-#include <conf/Config.h>
-
-#include <project.h>
-#include <raylib.h>
-#include <thread>
 #include "ApplicationUtils.h"
+
 using namespace Techstorm;
 
 void InitWindow(WindowDecorations& decorations) {
+
+	Log("Decorating window...");
 	decorations.title = LookupConfig("Project.cfg", "projectWindowTitle");
 	SetConfigFlags(FLAG_MSAA_4X_HINT | FLAG_INTERLACED_HINT);
+
+	Log("Finalizing window initialization...");
 	InitWindow(decorations.width, decorations.height, decorations.title);
 
+	Log("Loading and setting window icon...");
 	const char* iconPath = TextFormat("%s%s", TS_ASSET_DIR.c_str(), decorations.icon);
 
 	Image icon = LoadImage(iconPath);
@@ -52,37 +49,61 @@ class UI : public GameObject {
 };*/
 
 int main(int argc, char* argv[]) {
+	Log("Pre-Initializing project...");
 	PROJECT_TYPENAME project = PROJECT_TYPENAME();
 	project.preInit();
+	Log("Project pre-initialized.");
+
+	Log("Finishing Initialization...");
 
 	InitializeConfigRegistry();
 	ConfigFileRegistry& configRegistry = GetConfigFileRegistry();
 
 	Renderer& renderer = project.getRenderer();
 	WindowDecorations& decorations = project.getWindowDecorations();
 
+	Log("Setting up scripting API...");
 	ScriptingAPI scriptingAPI;
 
 	InitScripting(scriptingAPI, project);
 
+	Log("Done setting up scripting API.");
+
+	Log("Initializing window...");
 	InitWindow(decorations);
 
+	Log("Done initializing window.");
+
+	Log("Finishing project's initialization...");
 	project.init(argc, argv);
 	project.postInit();
 
+	Log("Done finishing project's initialization.");
+
+	Log("Launching threads.");
+
 	Techstorm::Application::FrameManager& manager = Techstorm::Application::FrameManager::Instance();
 
 	SetTargetFPS(decorations.targetFPS);
 
 	manager.launchThreads(project);
 
+	Log("Initialization is now finished, starting main loop.");
 	while (!WindowShouldClose()) {
-		//context->Update();
 		HandleFrame(project);
 	}
 
+	Log("Shutting down...");
+
+	Log("Cleaning up...");
 	project.cleanup(0);
 
+	manager.killThreads();
+
+	Log("Done cleaning up.");
+
 	CloseWindow();
+
+	Log("Done shutting down. Goodbye!");
 	return 0;
 }

src/application/ApplicationUtils.h

@@ -55,6 +55,7 @@ set(TS_UTIL_SOURCES
     "utils/DoublyLinkedList.h" 
     "utils/Gate.h" 
     "utils/Globals.h"
+    "utils/MiscUtils.h"
 )
 
 set(TS_MATH_SOURCES
@@ -144,6 +145,8 @@ set(TS_ENGINE_DEPENDENCIES
     rmlui_DEPS_TARGET
 
     spdlog::spdlog
+
+    fmt::fmt
 )
 
 include("${CMAKE_SOURCE_DIR}/CMakeOptions.txt")

src/application/main.cpp

@@ -25,6 +25,7 @@
 const std::string TS_ASSET_DIR = std::string(TS_TOP_LAYER) + "/game/assets/";
 const std::string TS_DATA_DIR = std::string(TS_TOP_LAYER) + "/game/data/";
 const std::string TS_GAME_DIR = std::string(TS_TOP_LAYER) + "/game/";
+const std::string TS_TEMP_DIR = std::string(TS_TOP_LAYER) + "/temp/";
 
 namespace Techstorm {
 
@@ -494,7 +495,24 @@ namespace Techstorm {
 	};*/
 
 
+	template<typename T>
+	class ReferenceHolder {
+	public:
 
+		explicit ReferenceHolder(T& value) : mValue(value) {}
+
+		void set(T& value) {
+			mValue = value;
+		}
+
+		T& get() {
+			return mValue;
+		}
+
+
+	private:
+		T& mValue;
+	};
 
 
 	/// This is a module for haptic experiences (ie. controller rumble) and helps make more immersive experiences. 

src/engine/CMakeLists.txt

@@ -4,6 +4,7 @@
 #include <any>
 #include <memory>
 #include <string>
+#include "../dbg/Logging.h"
 
 std::any LoadConfigFile(std::shared_ptr<Techstorm::FileMeta> fileMeta) {
 	using namespace Techstorm;
@@ -22,7 +23,12 @@ Techstorm::ConfigFileRegistry::~ConfigFileRegistry()
 }
 
 void Techstorm::ConfigFileRegistry::init() {
+	Log("Initializing config registry.");
+
+	// only show this in the log file
+	Log("Setting config file load functions.", ELogLevel::TRACE);
 	AddFileRegistryLoadFunction("cfg", [](std::shared_ptr<FileMeta> fileMeta) {
+		Log("Loading config file: " + fileMeta->path, ELogLevel::TRACE);
 		libconfig::Config* conf = new libconfig::Config();
 		conf->readFile(fileMeta->path);
 		return std::make_any<libconfig::Config*>(conf);
@@ -63,6 +69,8 @@ libconfig::Setting& Techstorm::ConfigFileRegistry::lookup(const std::string& fil
 	libconfig::Config const* conf = GetFile(fileName).get()->get<libconfig::Config*>();
 	libconfig::Setting& setting = conf->lookup(lookupTarget);
 
+	Log("Looking up value in :" + fileName + " for key: " + lookupTarget + " and found value: " + setting.c_str(), ELogLevel::TRACE);
+	
 	return setting;
 
 }

src/engine/Common.h

@@ -4,14 +4,15 @@
 namespace Techstorm {	
 	/// <summary>
 	/// What level of logging to use. This will affect the output color, severity, etc. 
-	/// \note This is not the same as spdlog's log level. Also, this inherits from uint8_t.
+	/// \note This is not the same as spdlog's log level. Also, this inherits from int to make it easier to compare.
 	/// </summary>
-	enum class ELogLevel : uint8_t {
+	enum class ELogLevel : int {
 		TRACE = 0,
 		DEBUG,
 		INFO,
 		WARNING,
 		ERROR,
-		FATAL
+		FATAL,
+		NONE
 	};
 }

src/engine/conf/Config.cpp

@@ -1,10 +1,87 @@
 #include "Logging.h"
-#include <spdlog/spdlog.h>
 
-Techstorm::Logger::Logger()
+
+
+void Techstorm::Logger::log(const std::string& message, ELogLevel level, const std::source_location& location)
 {
+    std::string locFileName = location.file_name();
+
+    // shorten the filename to only the last part of it
+	locFileName = locFileName.substr(locFileName.find_last_of("/\\") + 1);
+
+
+    int locLine = location.line();
+
+    std::string finalMessage = "[" + locFileName + ":" + std::to_string(locLine) + "] " + message;
+
+    switch (level)
+    {
+    case Techstorm::ELogLevel::TRACE:
+        mLogger->trace(finalMessage);
+        break;
+    case Techstorm::ELogLevel::DEBUG:
+		mLogger->debug(finalMessage);
+        break;
+    case Techstorm::ELogLevel::INFO:
+		mLogger->info(finalMessage);
+        break;
+    case Techstorm::ELogLevel::WARNING:
+		mLogger->warn(finalMessage);
+        break;
+    case Techstorm::ELogLevel::ERROR:
+		mLogger->error(finalMessage);
+        break;
+    case Techstorm::ELogLevel::FATAL:
+		mLogger->critical(finalMessage);
+        break;
+    case Techstorm::ELogLevel::NONE:
+        break;
+    default:
+#ifdef RELEASE
+        // if on release, log this as an error
+        std::string failMsg = "Failed to log the message: " + finalMessage;
+        failMsg << "Because the log level " << level << " is not supported!";
+		mLogger->error(failMsg);
+
+#else
+		mLogger->trace(finalMessage);
+#endif
+        break;
+    }
 }
 
-void Techstorm::Logger::Log(const std::string& message, const std::source_location& location)
+void Techstorm::TerminalSink::init()
 {
+    mColorSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    mColorSink->set_level(spdlog::level::warn);
+    mColorSink->set_pattern(mFormat);
+}
+
+std::string Techstorm::TerminalSink::getFormat()
+{
+    return this->mFormat;
+}
+
+std::string Techstorm::CreateLogFileName() {
+    // Filename should follow this format: YYYY-MM-DD_HH-MM-SS.log
+    time_t now = time(0);
+    struct tm tstruct;
+    localtime_s(&tstruct, &now);
+    char buf[80];
+    strftime(buf, sizeof(buf), "%Y-%m-%d_%H-%M-%S", &tstruct);
+
+    std::string name = std::string(TS_TEMP_DIR);
+	name += "logs/";
+	name += std::string(buf);
+	name += ".log";
+
+    return name;
+}
+
+spdlog::level::level_enum Techstorm::GetSpdlogLevel(ELogLevel level) {
+    return static_cast<spdlog::level::level_enum>(level);
+}
+
+void Techstorm::Log(const std::string& message, ELogLevel level, const std::source_location& location) {
+    Logger::Instance().log(message, level, location);
 }