zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-08-08 17:57:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: logger (#35)

Browse Source 
* refactor(log): convert Logger from namespace to class with static methods

- Replace the Logger namespace of free functions with a Logger class containing static methods (info, error, warn, debug).
- Simplify log calls by removing explicit source_location parameters; adopt `std::print` for output formatting.
- Undefine common macro names (DEBUG, INFO, ERROR, WARN) to avoid collisions.
- Update `renderer.cpp` to use `Logger::debug` instead of the old `Logger::log`.
- Add missing `#include <source_location>` in `audio_error.hpp`.
- Fix early return condition in `WorldScene::set_pause`.

* refactor(camera): remove reset_camera method and first-mouse flag

* refactor: replace --no-debug with logging options, add assertions, fix typo

- Removed `--no-debug` CLI flag and added `--logs-path`, `--log-level`, `--enable-filelog`, `--enable-consolelog`.
- Added file logging support with daily rotation, log level threshold, and console/file output control.
- Added `m_init` check in `Config::get`/`set` to prevent use before initialization.
- Fixed typo in `DebugCollector::destroy` (`distory` → `destory`).
- Removed `debug_on` parameter from `Renderer::init`; OpenGL debug output is now unconditionally enabled in debug builds.

* feat(debug): enable GL debug context flag in debug builds
This commit is contained in:
zhenyan121
2026-07-18 10:40:34 +08:00
committed by GitHub
parent 2b75c510af
commit 0f731530da
15 changed files with 292 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
src/app.cpp
View File

@@ -1,6 +1,5 @@
#include "Cubed/app.hpp"
#include "Cubed/camera.hpp"
#include "Cubed/config.hpp"
#include "Cubed/debug_collector.hpp"
#include "Cubed/localization.hpp"
@@ -25,13 +24,43 @@ App::App()
App::~App() {
stop_text_input();
Font::destroy();
DebugCollector::distory();
if (m_opengl_init) {
Font::destroy();
DebugCollector::destory();
}
}
void App::init(int argc, char** argv) {
handle_argument(argc, argv);
bool debug = false;
Logger::set_console_write(true);
#ifdef DEBUG_MODE
Logger::set_level(Logger::Level::DEBUG);
Logger::set_file_write(false);
debug = true;
#else
Logger::set_level(Logger::Level::INFO);
debug = false;
#endif
handle_argument(argc, argv);
if (m_argument.log_level) {
Logger::set_level(Logger::get_level(*m_argument.log_level));
}
if (m_argument.logs_path) {
Logger::set_logs_path(*m_argument.logs_path);
Logger::set_file_write(true);
}
if (!debug) {
Logger::set_file_write(true);
Logger::set_console_write(false);
}
if (m_argument.enable_consolelog) {
Logger::set_console_write(true);
}
if (m_argument.enable_filelog) {
Logger::set_file_write(true);
}
m_game_config.load_config();
if (m_argument.language) {
Localization::instance().load_language(*m_argument.language);
m_game_config.set("language", *m_argument.language);
@@ -47,16 +76,12 @@ void App::init(int argc, char** argv) {
m_window.init(m_argument);
m_window.imgui_init();
m_opengl_init = true;
Logger::info("Window Init Success");
m_audio.init();
BlockManager::init();
if (m_argument.no_debug) {
m_renderer.init(*m_argument.no_debug);
} else {
m_renderer.init(true);
}
m_renderer.init();
Logger::info("Renderer Init Success");
// MapTable::init_map();
m_texture_manager.init_texture();
@@ -90,16 +115,16 @@ void App::handle_argument(int argc, char** argv) {
int port;
auto r =
std::from_chars(arg.data(), arg.data() + arg.size(), port);
m_argument.port = port;
if (r.ec != std::errc{} || r.ptr != arg.data() + arg.size()) {
throw std::runtime_error(
std::format("Invalid port: {}", arg));
}
if (m_argument.port > 65535) {
if (port > 65535) {
throw std::runtime_error(
std::format("Port {} out of range", *m_argument.port));
std::format("Port {} out of range", port));
}
m_argument.port = port;
}},
{"--ip",
@@ -117,12 +142,6 @@ void App::handle_argument(int argc, char** argv) {
std::cout << CUBED_VERSION << "\n";
exit(EXIT_SUCCESS);
}},
{"--no-debug",
[&](ArgParser) {
m_argument.no_debug = false;
Logger::info("Switch off opengl debug out put");
}},
{"--language",
[&](ArgParser& p) {
auto arg = p.require_next("--language");
@@ -134,7 +153,32 @@ void App::handle_argument(int argc, char** argv) {
m_argument.video_driver = arg;
}},
{"--enable-exclusive",
[&](ArgParser&) { m_argument.enable_exclusive = true; }}
[&](ArgParser&) { m_argument.enable_exclusive = true; }},
{"--logs-path",
[&](ArgParser& p) {
m_argument.logs_path = p.require_next("--logs-path");
}},
{"--log-level",
[&](ArgParser& p) {
auto arg = p.require_next("--log-level");
int level;
auto r = std::from_chars(arg.data(), arg.data() + arg.size(),
level);
if (r.ec != std::errc{} || r.ptr != arg.data() + arg.size()) {
throw std::runtime_error(
std::format("Invalid log Level: {}", arg));
}
if (level > 3) {
throw std::runtime_error(
std::format("Level {} out of range", level));
}
m_argument.log_level = level;
}},
{"--enable-filelog",
[&](ArgParser&) { m_argument.enable_filelog = true; }},
{"--enale-consolelog",
[&](ArgParser&) { m_argument.enable_consolelog = true; }}
};
ArgParser parser(argc, argv);
@@ -563,10 +607,6 @@ void App::handle_sdl_mouse_button(SDL_Event& e) {
void App::handle_window_focus(bool focused) {
if (focused) {
auto camera = m_window.camera();
if (camera) {
camera->reset_camera();
}
}
}
@@ -675,6 +715,10 @@ void App::handle_sdl_event(SDL_Event& e) {
break;
case SDL_EVENT_MOUSE_MOTION:
if (!imgui_enable) {
if (std::abs(e.motion.xrel) > 200 ||
std::abs(e.motion.yrel) > 200) {
return;
}
handle_mouse_move(e.motion.x, e.motion.y, e.motion.xrel,
e.motion.yrel);
}

58
src/camera.cpp
View File

@@ -61,19 +61,12 @@ void Camera::update_move_camera() {
void Camera::camera_init(ClientPlayer* player) {
m_player = player;
update_move_camera();
reset_camera();
hot_reload();
}
void Camera::hot_reload() {}
void Camera::reset_camera() { m_firse_mouse = true; }
void Camera::update_cursor_position_camera(float offset_x, float offset_y) {
if (m_firse_mouse) {
m_firse_mouse = false;
return;
}
ASSERT_MSG(m_player, "nullptr");
m_player->update_front_vec(offset_x, offset_y);
@@ -109,34 +102,29 @@ bool Camera::is_first_person() const {
}
ClientPlayer* Camera::player() { return m_player; }
bool Camera::handle_event(const Event& e) {
return std::visit(Overloaded{[this](const MouseMoveEvent& e) {
if (handle_mouse_move_event(e)) {
return true;
}
return std::visit(
Overloaded{[this](const MouseMoveEvent& e) {
if (handle_mouse_move_event(e)) {
return true;
}
return false;
},
[](const MouseButtonEvent&) { return false; },
[](const MouseWheelEvent&) { return false; },
[this](const KeyEvent& e) {
if (handle_key_event(e)) {
return true;
}
return false;
},
[](const TextInputEvent&) { return false; },
[this](const WindowResizeEvent&) {
reset_camera();
return false;
},
[this](const FrameBufferResizeEvent&) {
reset_camera();
return false;
}
return false;
},
[](const MouseButtonEvent&) { return false; },
[](const MouseWheelEvent&) { return false; },
[this](const KeyEvent& e) {
if (handle_key_event(e)) {
return true;
}
return false;
},
[](const TextInputEvent&) { return false; },
[](const WindowResizeEvent&) { return false; },
[](const FrameBufferResizeEvent&) { return false; }
} // namespace Cubed
,
e);
} // namespace Cubed
,
e);
}
glm::vec3 Camera::camera_collision(glm::vec3 start, glm::vec3 end,
@@ -161,10 +149,6 @@ glm::vec3 Camera::camera_collision(glm::vec3 start, glm::vec3 end,
}
bool Camera::handle_key_event(const KeyEvent& e) {
if (e.key == Key::LEFT_ALT && e.action == KeyAction::PRESS) {
reset_camera();
return true;
}
if (e.key == Key::F5 && e.action == KeyAction::PRESS) {
change_perspective();
return true;

3
src/config.cpp
View File

@@ -10,7 +10,7 @@ using namespace std::string_view_literals;
namespace Cubed {
Config::Config(std::string_view path) : CONGIF_PATH(path) { load_config(); }
Config::Config(std::string_view path) : CONGIF_PATH(path) {}
Config::~Config() { save_to_file(); }
@@ -23,6 +23,7 @@ void Config::load_config() {
try {
m_tbl = toml::parse_file(config_path.string());
Logger::info("Load Config File Success");
m_init = true;
} catch (const toml::parse_error& err) {
Logger::error("Load Config Error: \"{}\"", err.what());
}

2
src/debug_collector.cpp
View File

@@ -17,7 +17,7 @@ std::unique_ptr<DebugCollector>& DebugCollector::get_ptr() {
std::make_unique<DebugCollector>();
return instance;
}
void DebugCollector::distory() { get_ptr().reset(); }
void DebugCollector::destory() { get_ptr().reset(); }
void DebugCollector::init(int width, int height) {
constexpr float SCALE = 0.6f;

22
src/render/renderer.cpp
View File

@@ -36,7 +36,7 @@ void Renderer::reload_config() {
update_fov(m_config.get("player.fov", 70.0f));
}
void Renderer::init(bool debug_on) {
void Renderer::init() {
Logger::info("OpenGL Version: {}.{}", GLVersion.major, GLVersion.minor);
Logger::info("Renderer: {}",
@@ -51,17 +51,15 @@ void Renderer::init(bool debug_on) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#ifdef DEBUG_MODE
if (debug_on) {
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(
[](GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar* message,
const void*) {
Logger::log(Logger::Level::L_DEBUG,
std::source_location::current(), "GL Debug: {}",
reinterpret_cast<const char*>(message));
},
nullptr);
}
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(
[](GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar* message,
const void*) {
Logger::debug("GL Debug: {}",
reinterpret_cast<const char*>(message));
},
nullptr);
#endif

3
src/scene/world_scene.cpp
View File

@@ -282,6 +282,9 @@ ClientWorld& WorldScene::client_world() { return m_client_world; }
ServerWorld& WorldScene::server_world() { return m_server.server_world(); }
bool WorldScene::pause() const { return m_paused; }
void WorldScene::set_pause(bool pause) {
if (m_paused == pause) {
return;
}
m_paused = pause;
auto& window = m_scene_manager.app().window();
window.set_game_running(!m_paused);

7
src/window.cpp
View File

@@ -238,6 +238,10 @@ void Window::init(const Argument& argument) {
SDL_SetWindowPosition(m_window, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED);
#ifdef DEBUG_MODE
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
Logger::debug("Debug Flag On");
#endif
}
void Window::reload_config() {
@@ -298,9 +302,6 @@ void Window::enable_mouse() {
}
void Window::disable_mouse() {
SDL_SetWindowRelativeMouseMode(m_window, true);
if (m_camera) {
m_camera->reset_camera();
}
m_mouse_enable = false;
}