NDT/EtrediaEmpires
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P7 Logger to module

Browse Source
This commit is contained in:
legatt 2026-02-18 22:27:30 +03:00
parent 04948d0d4d
commit 08477f316e
14 changed files with 173 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
engine-api/src/Render.cpp
View File

@ -1,12 +1,12 @@
module;
#include "Logger.h"
#include <GLFW/glfw3.h>
#include <glm/gtc/matrix_transform.hpp>
#include <ee_utils/utils.hpp>
module Render;
import std;
import utils;
ee_engine::IRenderer::IRenderer(GLFWwindow *window)
{

1
engine/modules/AssetManager.cppm
View File

@ -1,6 +1,5 @@
module;
#include "Logger.h"
#include "compile_config.hpp"
#include <ee_utils/utils.hpp>
#include <xxhash.h>

1
engine/src/Client.cpp
View File

@ -1,6 +1,5 @@
module;
#include "Logger.h"
#include <ee_utils/utils.hpp>
module Client;

3
engine/src/FileSystem.cpp
View File

@ -1,7 +1,6 @@
module;
#include "Logger.h"
#include <ee_utils/platform.hpp>
module FileSystem;
import utils;

2
engine/src/GLFWInput.cpp
View File

@ -1,6 +1,5 @@
module;
#include "Logger.h"
#include <GLFW/glfw3.h>
#define GLFW_GET_INPUT reinterpret_cast<GLFWInput*>(glfwGetWindowUserPointer(window))
@ -8,6 +7,7 @@ module;
module GLFWInput;
import Engine;
import utils;
GLFWInput::GLFWInput(ee_engine::InputHandlers handlers) : ee_engine::IInput(handlers)
{

14
engine/src/main.cpp
View File

@ -1,4 +1,3 @@
#include "Logger.h"
#include "compile_config.hpp"
#include <GLFW/glfw3.h>
@ -10,15 +9,11 @@ import MagnumRender;
import GLFWInput;
import std;
IP7_Trace* Logger::trace;
int main(int argc, char **argv)
{
// Setup P7 logger
IP7_Client *p7client = P7_Create_Client(P7_SINK P7_LOGS_PATH);
P7_Set_Crash_Handler();
Logger::trace = P7_Create_Trace(p7client, L"TC 1");
Logger::trace->Register_Thread(L"Main", 0);
Logger::Init(P7_SINK P7_LOGS_PATH);
Logger::RegisterThread(L"Main");
LOG(INFO, "Etredia Empires, v%d.%d.%d", MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION);
@ -98,9 +93,8 @@ int main(int argc, char **argv)
// Free memory
LOG(INFO, "Exit...");
Engine::Shutdown();
Logger::trace->Unregister_Thread(0);
Logger::trace->Release();
p7client->Release();
Logger::UnregisterThread();
Logger::Release();
return 0;
}

10
p7lib/Headers/Logger.h
View File

@ -1,10 +0,0 @@
#pragma once
#include "P7_Trace.h"
#define LOG(level, format, ...) Logger::trace->P7_DELIVER(0, EP7TRACE_LEVEL_##level, NULL, TM(format), __VA_ARGS__)
class Logger
{
public:
static IP7_Trace *trace;
};

2
renderers/magnum-renderer/src/Materials.cpp
View File

@ -7,10 +7,10 @@ module;
#include <Magnum/GL/Version.h>
#include <Magnum/Math/Matrix4.h>
#include "Logger.h"
module MagnumRender;
import :Materials;
import utils;
ee_magnum::BaseMaterial::BaseMaterial(const std::string &vertSrc, const std::string &fragSrc)
{

2
renderers/magnum-renderer/src/Render.cpp
View File

@ -2,8 +2,6 @@ module;
#define NOMINMAX
#include "Logger.h"
#include <Magnum/Platform/GLContext.h>
#include <Magnum/GL/Mesh.h>
#include <Magnum/GL/Buffer.h>

4
utils/include/ee_utils/platform.hpp
View File

@ -2,7 +2,11 @@
#define ETREDIAEMPIRES_PLATFORM_HPP
#ifdef _WIN32
#include <Windows.h>
#define WIN_ERROR 0
#undef ERROR
#endif
#ifdef __linux__

9
utils/modules/lockfree.cppm
View File

@ -5,7 +5,10 @@ module;
export module utils:lockfree;
export using boost::lockfree::capacity;
export namespace boost
{
using lockfree::capacity;
export using boost::lockfree::queue;
export using boost::lockfree::spsc_queue;
using lockfree::queue;
using lockfree::spsc_queue;
}

148
utils/modules/logger.cppm Normal file
View File

@ -0,0 +1,148 @@
module;
#include <P7_Trace.h>
#undef ERROR
#undef TM
export module utils:logger;
import std;
namespace logger
{
template <std::size_t length>
struct wstring
{
wchar_t content[length];
constexpr operator const wchar_t*() const {return content;}
explicit constexpr wstring(const char (&str)[length]) : content{}
{
for (std::size_t i = 0; i < length; i++)
content[i] = static_cast<wchar_t>(str[i]);
}
};
template <std::size_t length>
constexpr wstring<length> TM(const char (&str)[length])
{
return wstring<length>(str);
}
enum LogLevel : std::uint8_t
{
TRACE,
DEBUG,
INFO,
WARNING,
ERROR,
CRITICAL,
};
class Logger;
template <typename... Args>
struct LOG_WCHAR
{
LOG_WCHAR(
LogLevel level,
const wchar_t* format,
Args&&... args,
const std::source_location &location = std::source_location::current()
)
{
Logger::trace->Trace(
0,
static_cast<eP7Trace_Level>(level),
nullptr,
location.line(),
location.file_name(),
location.function_name(),
format,
std::forward<Args>(args)...
);
}
};
// Notice: logging char string supports only ASCII, use LOG_WCHAR with wchar string for UTF-8
template <std::size_t length, typename... Args>
struct LOG
{
LOG(
LogLevel level,
const char (&format)[length],
Args&&... args,
const std::source_location &location = std::source_location::current()
)
{
Logger::trace->Trace(
0,
static_cast<eP7Trace_Level>(level),
nullptr,
location.line(),
location.file_name(),
location.function_name(),
TM(format),
std::forward<Args>(args)...
);
}
};
template <typename... Args> LOG_WCHAR(LogLevel, const wchar_t*, Args&&...) -> LOG_WCHAR<Args...>;
template <std::size_t length, typename... Args> LOG(LogLevel, const char (&)[length], Args&&...) -> LOG<length, Args...>;
class Logger
{
public:
Logger() = delete;
static void Init(const wchar_t *options)
{
if (isReady)
{
LOG_WCHAR(WARNING, L"Logger already initialized.");
return;
}
client = P7_Create_Client(options);
P7_Set_Crash_Handler();
trace = P7_Create_Trace(client, L"TC 1");
isReady = true;
}
static void Release()
{
trace->Release();
client->Release();
}
static void RegisterThread(const wchar_t *name)
{
trace->Register_Thread(name, 0);
}
static void UnregisterThread()
{
trace->Unregister_Thread(0);
}
private:
inline static IP7_Client *client = nullptr;
inline static IP7_Trace *trace = nullptr;
inline static bool isReady = false;
template <typename... Args> friend struct LOG_WCHAR;
template <std::size_t length, typename... Args> friend struct LOG;
};
}
export using logger::Logger;
export using logger::LOG_WCHAR;
export using logger::LOG;
export using logger::LogLevel::TRACE;
export using logger::LogLevel::DEBUG;
export using logger::LogLevel::INFO;
export using logger::LogLevel::WARNING;
export using logger::LogLevel::ERROR;
export using logger::LogLevel::CRITICAL;

1
utils/modules/utils.cppm
View File

@ -3,5 +3,6 @@ export import :allocator;
export import :worker;
export import :buffers;
export import :lockfree;
export import :logger;
export namespace ee_utils {}

12
utils/modules/worker.cppm
View File

@ -1,9 +1,6 @@
module;
#include "Logger.h"
export module utils:worker;
import :lockfree;
import :logger;
import std;
export namespace ee_utils
@ -48,6 +45,8 @@ export namespace ee_utils
// TODO: maybe I should use lockfree::queue ?
boost::lockfree::spsc_queue<TCommand, boost::lockfree::capacity<512>> commands;
Worker() {};
void ProcessCommand(TCommand &command)
{
if (command.type > maxCmdType || !commandsMapping[command.type])
@ -110,7 +109,7 @@ export namespace ee_utils
void Threading()
{
Logger::trace->Register_Thread(threadName, 0);
Logger::RegisterThread(threadName);
LOG(INFO, "Thread started");
Loop();
@ -121,6 +120,7 @@ export namespace ee_utils
void Loop()
{
TCommand commandBuffer{};
// ReSharper disable once CppTooWideScope
std::vector<TCommand> incompleteCommands;
while (!stoken->stop_requested())
{
@ -138,7 +138,7 @@ export namespace ee_utils
{
Release();
LOG(INFO, "Thread is released");
Logger::trace->Unregister_Thread(0);
Logger::UnregisterThread();
isRunning.store(false);
}
};