Remove logger

.gitmodules

@@ -7,7 +7,4 @@
 [submodule "external/sourcesdk"]
 	path = external/sourcesdk
 	url = https://github.com/Wend4r/sourcesdk/
-	branch = cs2
-[submodule "external/logger"]
-	path = external/logger
-	url = https://github.com/untrustedmodders/s2u-logger.git
+	branch = main

CMakeLists.txt

@@ -44,13 +44,11 @@ function(set_or_external_dir VAR_NAME TARGET)
 	set(${VAR_NAME} "${${VAR_NAME}}" PARENT_SCOPE)
 endfunction()
 
-set_or_external_dir(LOGGER_DIR "logger")
 set_or_external_dir(METAMOD_DIR "metamod-source")
 set_or_external_dir(PLUGIFY_DIR "plugify")
 set_or_external_dir(SOURCESDK_DIR "sourcesdk")
 
 include(cmake/platform/shared.cmake)
-include(cmake/logger.cmake)
 include(cmake/metamod.cmake)
 include(cmake/plugify.cmake)
 include(cmake/sourcesdk.cmake)
@@ -87,10 +85,10 @@ if(UNIX)
 	endif()
 endif()
 
-target_compile_definitions(${PROJECT_NAME} PRIVATE ${COMPILE_DEFINITIONS} ${LOGGER_COMPILE_DEFINITIONS} ${METAMOD_COMPILE_DEFINITIONS} ${PLUGIFY_COMPILE_DEFINITIONS})
-target_include_directories(${PROJECT_NAME} PRIVATE ${INCLUDE_DIRS} ${LOGGER_INCLUDE_DIRS} ${METAMOD_INCLUDE_DIRS} ${PLUGIFY_INCLUDE_DIRS})
+target_compile_definitions(${PROJECT_NAME} PRIVATE ${METAMOD_COMPILE_DEFINITIONS} ${PLUGIFY_COMPILE_DEFINITIONS})
+target_include_directories(${PROJECT_NAME} PRIVATE ${METAMOD_INCLUDE_DIRS} ${PLUGIFY_INCLUDE_DIRS})
 
-target_link_libraries(${PROJECT_NAME} PRIVATE ${LOGGER_BINARY_DIR} ${PLUGIFY_BINARY_DIR} ${PLUGIFY_LINK_LIBRARIES} ${SOURCESDK_BINARY_DIR})
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PLUGIFY_BINARY_DIR} ${PLUGIFY_LINK_LIBRARIES} ${SOURCESDK_BINARY_DIR})
 
 configure_file(
 	${CMAKE_SOURCE_DIR}/plugify.pconfig.in

src/mm_logger.cpp

@@ -1,61 +1,134 @@
 #include "mm_logger.h"
+#include "mm_plugin.h"
 
 using namespace plugifyMM;
 
+MMLogger::MMLogger(const char *name, RegisterTagsFunc registerTagsFunc, int flags, LoggingVerbosity_t verbosity, const Color &defaultColor)
+{
+	m_channelID = LoggingSystem_RegisterLoggingChannel(name, registerTagsFunc, flags, verbosity, defaultColor);
+}
+
+bool MMLogger::IsChannelEnabled(LoggingSeverity_t severity) const
+{
+	return LoggingSystem_IsChannelEnabled(m_channelID, severity);
+}
+
+bool MMLogger::IsChannelEnabled(LoggingVerbosity_t verbosity) const
+{
+	return LoggingSystem_IsChannelEnabled(m_channelID, verbosity);
+}
+
+LoggingVerbosity_t MMLogger::GetChannelVerbosity() const
+{
+	return LoggingSystem_GetChannelVerbosity(m_channelID);
+}
+
+Color MMLogger::GetColor() const
+{
+	Color rgba;
+	rgba.SetRawColor(LoggingSystem_GetChannelColor(m_channelID));
+	return rgba;
+}
+
+LoggingChannelFlags_t MMLogger::GetFlags() const
+{
+	return LoggingSystem_GetChannelFlags(m_channelID);
+}
+
 void MMLogger::SetSeverity(plugify::Severity severity)
 {
 	m_severity = severity;
 }
 
+LoggingResponse_t MMLogger::Log(LoggingSeverity_t severity, const char *message) const
+{
+	LoggingResponse_t response = LR_ABORT;
+
+	if (IsChannelEnabled(severity))
+	{
+		response = LoggingSystem_LogDirect(m_channelID, severity, message);
+	}
+
+	return response;
+}
+
+LoggingResponse_t MMLogger::Log(LoggingSeverity_t severity, const Color &color, const char *message) const
+{
+	LoggingResponse_t response = LR_ABORT;
+
+	if (IsChannelEnabled(severity))
+	{
+		response = LoggingSystem_LogDirect(m_channelID, severity, color, message);
+	}
+
+	return response;
+}
+
+LoggingResponse_t MMLogger::Log(LoggingSeverity_t severity, const LeafCodeInfo_t &code, const char *message) const
+{
+	LoggingResponse_t response = LR_ABORT;
+
+	if (IsChannelEnabled(severity))
+	{
+		response = LoggingSystem_LogDirect(m_channelID, severity, code, message);
+	}
+
+	return response;
+}
+
+LoggingResponse_t MMLogger::Log(LoggingSeverity_t severity, const LeafCodeInfo_t &code, const Color &color, const char *message) const
+{
+	LoggingResponse_t response = LR_ABORT;
+
+	if (IsChannelEnabled(severity))
+	{
+		response = LoggingSystem_LogDirect(m_channelID, severity, code, color, message);
+	}
+
+	return response;
+}
+
 void MMLogger::Log(std::string_view message, plugify::Severity severity)
 {
 	if (severity <= m_severity)
 	{
 		std::string sMessage = std::format("{}\n", message);
 
-		const char *pszMessage = sMessage.c_str();
-
 		switch (severity)
 		{
 			case plugify::Severity::Fatal:
 			{
-				Error({255, 0, 255, 255}, pszMessage);
-
+				Log(LS_ERROR, Color(255, 0, 255, 255), sMessage.c_str());
 				break;
 			}
 
 			case plugify::Severity::Error:
 			{
-				Warning({255, 0, 0, 255}, pszMessage);
-
+				Log(LS_WARNING, Color(255, 0, 0, 255), sMessage.c_str());
 				break;
 			}
 
 			case plugify::Severity::Warning:
 			{
-				Warning({255, 127, 0, 255}, pszMessage);
-
+				Log(LS_WARNING, Color(255, 127, 0, 255), sMessage.c_str());
 				break;
 			}
 
 			case plugify::Severity::Info:
 			{
-				Message({255, 255, 0, 255}, pszMessage);
-
+				Log(LS_MESSAGE, Color(255, 255, 0, 255),sMessage.c_str());
 				break;
 			}
 
 			case plugify::Severity::Debug:
 			{
-				Detailed({0, 255, 255, 255}, pszMessage);
-
+				Log(LS_MESSAGE, Color(0, 255, 0, 255), sMessage.c_str());
 				break;
 			}
 
 			case plugify::Severity::Verbose:
 			{
-				Detailed({255, 255, 255, 255}, pszMessage);
-
+				Log(LS_MESSAGE, Color(255, 255, 255, 255), sMessage.c_str());
 				break;
 			}
 

src/mm_logger.h

@@ -1,34 +1,38 @@
 #pragma once
 
-#include <functional>
-#include <string>
+#include <string_view>
 
 #include <tier0/dbg.h>
 #include <tier0/logging.h>
 
 #include <plugify/log.h>
 #include <plugify/compat_format.h>
 
-#include <logger.hpp>
-
 namespace plugifyMM
 {
-	using MMLoggerBase = Logger;
-
-	class MMLogger final : public MMLoggerBase, public plugify::ILogger
+	class MMLogger final : public plugify::ILogger
 	{
 	public:
-		using Base = MMLoggerBase;
-		using Base::Base;
-
+		MMLogger(const char *name, RegisterTagsFunc registerTagsFunc, int flags = 0, LoggingVerbosity_t verbosity = LV_DEFAULT, const Color &defaultColor = UNSPECIFIED_LOGGING_COLOR);
 		~MMLogger() override = default;
 
-		void SetSeverity(plugify::Severity severity);
+		bool IsChannelEnabled(LoggingSeverity_t severity) const;
+		bool IsChannelEnabled(LoggingVerbosity_t verbosity) const;
+		LoggingVerbosity_t GetChannelVerbosity() const;
+		Color GetColor() const;
+		LoggingChannelFlags_t GetFlags() const;
+
+		LoggingResponse_t Log(LoggingSeverity_t severity, const char *message) const;
+		LoggingResponse_t Log(LoggingSeverity_t severity, const Color &color, const char *message) const;
+		LoggingResponse_t Log(LoggingSeverity_t severity, const LeafCodeInfo_t &code, const char *message) const;
+		LoggingResponse_t Log(LoggingSeverity_t severity, const LeafCodeInfo_t &code, const Color &color, const char *message) const;
 
-	public: // plugify::ILogger
-		void Log(std::string_view message, plugify::Severity severity);
+		/*plugify*/
+		void Log(std::string_view message, plugify::Severity severity) override;
+		void SetSeverity(plugify::Severity severity);
 
 	private:
-		plugify::Severity m_severity { plugify::Severity::None };
+		plugify::Severity m_severity{ plugify::Severity::None };
+		LoggingChannelID_t m_channelID;
 	};
 } // namespace plugifyMM

src/mm_plugin.cpp

@@ -56,8 +56,8 @@ namespace plugifyMM
 	PlugifyMMPlugin g_Plugin;
 	PLUGIN_EXPOSE(PlugifyMMPlugin, g_Plugin);
 
-	#define CONPRINT(x) g_Plugin.m_logger->Message(x)
-	#define CONPRINTE(x) g_Plugin.m_logger->Warning(x)
+	#define CONPRINT(x) g_Plugin.m_logger->Log(LS_MESSAGE, x)
+	#define CONPRINTE(x) g_Plugin.m_logger->Log(LS_WARNING, x)
 
 	template <typename S, typename T, typename F> requires (std::is_function_v<F>)
 	void Print(std::string& out, const T &t, F &f, std::string_view tab = "  ")