initial import, >900commits predate this

framework/logger/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.2)
+project(logger CXX)
+
+file(GLOB_RECURSE CPP_FILES src/*.cpp)
+file(GLOB_RECURSE HPP_FILES src/*.hpp)
+
+add_library(logger ${CPP_FILES} ${HPP_FILES})
+
+target_include_directories(logger PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src")
+
+#target_compile_definitions(logger PUBLIC SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
+target_compile_definitions(logger PUBLIC SPDLOG_ACTIVE_LEVEL=0)
+
+target_link_libraries(logger
+	spdlog
+	tracy_client
+)
+
+#if (BUILD_TESTING)
+	#add_subdirectory(test)
+#endif()
+
+

framework/logger/src/mm/logger.cpp

@@ -0,0 +1,85 @@
+#include "./logger.hpp"
+
+#include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
+
+#include "./tracy_sink.hpp"
+#include "spdlog/spdlog.h"
+
+namespace MM {
+	bool Logger::initialized = false;
+
+	spdlog::sink_ptr Logger::_sink_console = nullptr;
+	spdlog::sink_ptr Logger::_sink_file = nullptr;
+
+#ifdef TRACY_ENABLE
+	spdlog::sink_ptr Logger::_sink_tracy = nullptr;
+#endif
+
+
+	void Logger::init(void) {
+		_sink_console = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+		_sink_console->set_level(spdlog::level::info);
+		//console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
+
+		_sink_file = std::make_shared<spdlog::sinks::basic_file_sink_mt>("mm_log.txt", true);
+		_sink_file->set_level(spdlog::level::trace);
+
+#ifdef TRACY_ENABLE
+		_sink_tracy = std::make_shared<spdlog::sinks::tracy_sink_mt>();
+		_sink_tracy->set_level(spdlog::level::trace);
+#endif
+
+		spdlog::set_default_logger(
+			std::make_shared<spdlog::logger>("MushMachine", spdlog::sinks_init_list(
+				{_sink_console, _sink_file
+#ifdef TRACY_ENABLE
+				, _sink_tracy
+#endif
+				}
+			))
+		);
+
+		spdlog::default_logger_raw()->set_level(spdlog::level::trace);
+
+		initialized = true;
+	}
+
+	void Logger::initSectionLogger(const char* section, bool log_to_stdio) {
+		if (spdlog::get(section)) { // already present
+			SPDLOG_WARN("tried to reinit '{}' section logger!", section);
+			return;
+		}
+
+		if (log_to_stdio) {
+			auto section_logger = std::make_shared<spdlog::logger>(
+					section, spdlog::sinks_init_list({
+						_sink_console,
+						_sink_file
+#ifdef TRACY_ENABLE
+						, _sink_tracy
+#endif
+					})
+			);
+
+			section_logger->set_level(spdlog::level::trace);
+
+			spdlog::register_logger(section_logger);
+		} else { // TODO: make better
+			auto section_logger = std::make_shared<spdlog::logger>(
+					section, spdlog::sinks_init_list({
+						_sink_file
+#ifdef TRACY_ENABLE
+						, _sink_tracy
+#endif
+					})
+			);
+
+			section_logger->set_level(spdlog::level::trace);
+
+			spdlog::register_logger(section_logger);
+		}
+	}
+
+}
+

framework/logger/src/mm/logger.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#define SPDLOG_ACTIVE_LEVEL 0
+
+#include <memory>
+#include <spdlog/spdlog.h>
+
+// thos are helpers so you can do "#define LOG_ERROR(...) __LOG_ERROR("Engine", ...)
+#define __LOG_CRIT(s, ...)		SPDLOG_LOGGER_CRITICAL(	spdlog::get(s), __VA_ARGS__)
+#define __LOG_ERROR(s, ...)		SPDLOG_LOGGER_ERROR(	spdlog::get(s), __VA_ARGS__)
+#define __LOG_WARN(s, ...)		SPDLOG_LOGGER_WARN(		spdlog::get(s), __VA_ARGS__)
+#define __LOG_INFO(s, ...)		SPDLOG_LOGGER_INFO(		spdlog::get(s), __VA_ARGS__)
+#define __LOG_DEBUG(s, ...)		SPDLOG_LOGGER_DEBUG(	spdlog::get(s), __VA_ARGS__)
+#define __LOG_TRACE(s, ...)		SPDLOG_LOGGER_TRACE(	spdlog::get(s), __VA_ARGS__)
+
+// copy paste me to start
+//#define LOG_CRIT(...)		__LOG_CRIT(	"Engine", __VA_ARGS__)
+//#define LOG_ERROR(...)		__LOG_ERROR("Engine", __VA_ARGS__)
+//#define LOG_WARN(...)		__LOG_WARN(	"Engine", __VA_ARGS__)
+//#define LOG_INFO(...)		__LOG_INFO(	"Engine", __VA_ARGS__)
+//#define LOG_DEBUG(...)		__LOG_DEBUG("Engine", __VA_ARGS__)
+//#define LOG_TRACE(...)		__LOG_TRACE("Engine", __VA_ARGS__)
+
+// copy paste me to end if in header
+//#undef LOG_CRIT
+//#undef LOG_ERROR
+//#undef LOG_WARN
+//#undef LOG_INFO
+//#undef LOG_DEBUG
+//#undef LOG_TRACE
+
+
+// DONT USE! this exists only for legacy reasons!
+#define LOG(s, x) SPDLOG_WARN("[!][{}] {}", s, x)
+//#define LOG(s, x) MM::Logger::log(MM::Logger::file_name(__FILE__), __LINE__, s, x)
+
+namespace MM {
+
+	struct Logger {
+		static bool initialized;
+
+		//static std::shared_ptr<spdlog::sinks::sink> _sink_console;
+		static spdlog::sink_ptr _sink_console;
+		static spdlog::sink_ptr _sink_file;
+
+#ifdef TRACY_ENABLE
+		static spdlog::sink_ptr _sink_tracy;
+#endif
+
+		static void init(void);
+
+		static void initSectionLogger(const char* section, bool log_to_stdio = true);
+	};
+
+} // namespace MM
+

framework/logger/src/mm/tracy_sink.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#ifdef TRACY_ENABLE
+
+#include <spdlog/sinks/base_sink.h>
+#include <tracy/Tracy.hpp>
+
+namespace spdlog::sinks {
+
+static uint32_t level_to_color(spdlog::level::level_enum level) {
+	switch (level) {
+		case level::level_enum::trace:		return 0xFFFFFF;
+		case level::level_enum::debug:		return 0x1111FF;
+		case level::level_enum::info:		return 0x11FF11;
+		case level::level_enum::warn:		return 0xFFFF11;
+		case level::level_enum::err:		return 0xFF1111;
+		case level::level_enum::critical:	return 0xFF0000;
+		default:							return 0xffffff;
+	}
+}
+
+template<typename Mutex>
+class tracy_sink : public ::spdlog::sinks::base_sink <Mutex> {
+	public:
+		tracy_sink(void) {
+			this->set_pattern("[%n] [%l] %v");
+		}
+	protected:
+		void sink_it_(const spdlog::details::log_msg& msg) override {
+
+			// log_msg is a struct containing the log entry info like level, timestamp, thread id etc.
+			// msg.raw contains pre formatted log
+
+			// If needed (very likely but not mandatory), the sink formats the message before sending it to its final destination:
+			spdlog::memory_buf_t formatted;
+			base_sink<Mutex>::formatter_->format(msg, formatted);
+			auto string = fmt::to_string(formatted);
+			TracyMessageC(string.data(), string.size(), level_to_color(msg.level))
+		}
+
+		void flush_() override {
+		}
+};
+
+} // spdlog::sinks
+
+#include <spdlog/details/null_mutex.h>
+#include <mutex>
+
+namespace spdlog::sinks {
+	using tracy_sink_mt = tracy_sink<std::mutex>;
+	using tracy_sink_st = tracy_sink<spdlog::details::null_mutex>;
+} // spdlog::sinks
+
+#endif // TRACY_ENABLE
+