refactor(debug): add d_rep template and remove widget ID

include/Cubed/debug_collector.hpp

@@ -4,6 +4,7 @@
 #include "Cubed/ui/label.hpp"
 #include "Cubed/ui/widget.hpp"
 
+#include <format>
 #include <unordered_map>
 
 namespace Cubed {
@@ -23,4 +24,11 @@ private:
     std::unordered_map<std::string, Label*> m_component;
 };
 
+template <typename... Args>
+void d_rep(const std::string& key, std::format_string<Args...> fmt,
+           Args&&... args) {
+    std::string msg = std::vformat(fmt.get(), std::make_format_args(args...));
+    DebugCollector::get().report(key, msg);
+}
+
 } // namespace Cubed

include/Cubed/tools/system_info.hpp

@@ -157,6 +157,36 @@ inline std::string get_cpu_info() {
 #endif
 }
 
+inline std::string get_compiler_info() {
+    std::string result;
+
+#if defined(__clang__)
+    result = "Clang ";
+    result += __clang_version__;
+
+#elif defined(__GNUC__)
+    result = "GCC ";
+    result += std::to_string(__GNUC__);
+    result += ".";
+    result += std::to_string(__GNUC_MINOR__);
+    result += ".";
+    result += std::to_string(__GNUC_PATCHLEVEL__);
+
+#elif defined(_MSC_VER)
+    result = "MSVC ";
+    result += std::to_string(_MSC_VER);
+
+#else
+    result = "Unknown Compiler";
+#endif
+
+    result += " (C++";
+    result += std::to_string(__cplusplus);
+    result += ")";
+
+    return result;
+}
+
 } // namespace Tools
 
 } // namespace Cubed

include/Cubed/ui/label.hpp

@@ -10,7 +10,6 @@ public:
     Label& operator=(const Label&) = delete;
     Label& operator=(Label&&) = delete;
 
-    Label(const std::string& id, Widget* parent);
     Label(Widget* parent);
     virtual ~Label() = default;
 

include/Cubed/ui/widget.hpp

@@ -25,12 +25,10 @@ public:
     Widget& operator=(const Widget&) = delete;
     Widget& operator=(Widget&&) = delete;
 
-    Widget(const std::string& id, Widget* parent);
     Widget(Widget* parent);
     virtual ~Widget() = default;
     virtual void update(float dt);
     virtual void render(Renderer& renderer);
-    virtual const std::string& id() const;
     virtual Widget& set_anchor(Anchor anchor);
     virtual Widget& set_offset(glm::ivec2 offset);
     virtual Widget& set_window_size(int width, int height);
@@ -58,7 +56,6 @@ public:
 
 protected:
     Widget* m_parent = nullptr;
-    std::string m_id;
     float m_window_height = 0;
     float m_window_width = 0;
     // Center is at the top-left corner, position is at the top-left corner

src/app.cpp

@@ -561,16 +561,15 @@ void App::handle_window_focus(bool focused) {
 void App::handle_window_resize(int width, int height) {
 
     dispatch_event(WindowResizeEvent{width, height});
-
+    d_rep("window_size", "Window W: {} H: {}", width, height);
     Logger::info("Window Reshape W: {} H: {}", width, height);
 }
 void App::handle_framebuffer_resize(int width, int height) {
     dispatch_event(FrameBufferResizeEvent{width, height});
-
+    d_rep("frame_buffer", "FrameBuffer W: {} H: {}", width, height);
     Logger::info("Frame Buffer Reshape W: {} H: {}", width, height);
 }
 void App::handle_mouse_scroll(float, float yoffset) {
-
     dispatch_event(MouseWheelEvent(yoffset));
 }
 
@@ -618,11 +617,8 @@ void App::update() {
 
         frame_count = 0;
         fps_time_count = 0.0f;
-        DebugCollector::get().report(
+        d_rep("fps", "FPS: {}", fps);
-            "fps", std::string{"FPS: " + std::to_string(fps)});
+        d_rep("rss", "RSS: {}mb", Tools::get_current_rss() / (1024 * 1024));
-        DebugCollector::get().report(
-            "rss",
-            std::format("RSS: {}mb", Tools::get_current_rss() / (1024 * 1024)));
     }
     m_texture_manager.update();
 

src/debug_collector.cpp

@@ -21,7 +21,7 @@ void DebugCollector::init(int width, int height) {
     m_widget.set_offset({0, 5});
     m_widget.set_child_anchor(ColumnLayoutAnchor::LEFT);
     // version_text
-    auto& version_text = m_widget.add_child<Label>("version");
+    auto& version_text = m_widget.add_child<Label>();
     std::string version{"Version: " CUBED_VERSION};
 
 #ifdef DEBUG_MODE
@@ -31,31 +31,35 @@ void DebugCollector::init(int width, int height) {
 #endif
 
     version_text.set_color(Color::WHITE).set_text(version).set_scale(SCALE);
-    m_component.try_emplace(version_text.id(), &version_text);
+
+    {
+        auto& compiler = m_widget.add_child<Label>();
+        compiler.set_text(Tools::get_compiler_info()).set_scale(SCALE);
+    }
 
     // fps
-    auto& fps_text = m_widget.add_child<Label>("fps");
+    auto& fps_text = m_widget.add_child<Label>();
     fps_text.set_text("FPS: 0").set_scale(SCALE);
-    m_component.try_emplace(fps_text.id(), &fps_text);
+    m_component.try_emplace("fps", &fps_text);
 
     // player_pos
-    auto& player_pos_text = m_widget.add_child<Label>("player_pos");
+    auto& player_pos_text = m_widget.add_child<Label>();
     player_pos_text.set_text("x: 0.00 y: 0.00 z: 0.00").set_scale(SCALE);
-    m_component.try_emplace(player_pos_text.id(), &player_pos_text);
+    m_component.try_emplace("player_pos", &player_pos_text);
 
     // rendered_chunk
-    auto& rendered_chunk_text = m_widget.add_child<Label>("rendered_chunk");
+    auto& rendered_chunk_text = m_widget.add_child<Label>();
     rendered_chunk_text.set_text("Rendered Chunk: 0").set_scale(SCALE);
-    m_component.try_emplace(rendered_chunk_text.id(), &rendered_chunk_text);
+    m_component.try_emplace("rendered_chunk", &rendered_chunk_text);
 
     // rss
-    auto& rss_text = m_widget.add_child<Label>("rss");
+    auto& rss_text = m_widget.add_child<Label>();
     rss_text.set_text("RSS: 0mb").set_scale(SCALE);
-    m_component.try_emplace(rss_text.id(), &rss_text);
+    m_component.try_emplace("rss", &rss_text);
 
     // os
     std::string os;
-    auto& os_text = m_widget.add_child<Label>("os");
+    auto& os_text = m_widget.add_child<Label>();
     os_text.set_scale(SCALE);
     if (Tools::get_os_version(os)) {
         os_text.set_text("OS: " + os);
@@ -63,38 +67,39 @@ void DebugCollector::init(int width, int height) {
     } else {
         os_text.set_text("OS: Unknown");
     }
-    m_component.try_emplace(os_text.id(), &os_text);
 
     // cpu
-    auto& cpu_text = m_widget.add_child<Label>("cpu");
+    auto& cpu_text = m_widget.add_child<Label>();
     cpu_text.set_text("CPU: " + Tools::get_cpu_info()).set_scale(SCALE);
-    m_component.try_emplace(cpu_text.id(), &cpu_text);
 
     // gpu
-    auto& gpu_text = m_widget.add_child<Label>("gpu");
+    auto& gpu_text = m_widget.add_child<Label>();
     gpu_text
         .set_text(std::string{"GPU: "} +
                   reinterpret_cast<const char*>(glGetString(GL_RENDERER)))
         .set_scale(SCALE);
-    m_component.try_emplace(gpu_text.id(), &gpu_text);
 
     // opengl_version
-    auto& opengl_version_text = m_widget.add_child<Label>("opengl_version");
+    auto& opengl_version_text = m_widget.add_child<Label>();
     opengl_version_text
         .set_text("OpenGL: " + std::to_string(GLVersion.major) + "." +
                   std::to_string(GLVersion.minor))
         .set_scale(SCALE);
-    m_component.try_emplace(opengl_version_text.id(), &opengl_version_text);
-
-    // biome
-    auto& biome_text = m_widget.add_child<Label>("biome");
-    biome_text.set_text("Biome: ").set_scale(SCALE);
-    m_component.try_emplace(biome_text.id(), &biome_text);
 
     // speed
-    auto& speed_text = m_widget.add_child<Label>("speed");
+    auto& speed_text = m_widget.add_child<Label>();
     speed_text.set_text("Speed: 0 m/s").set_scale(SCALE);
-    m_component.try_emplace(speed_text.id(), &speed_text);
+    m_component.try_emplace("speed", &speed_text);
+    {
+        auto& window_size = m_widget.add_child<Label>();
+        window_size.set_text("Window W: {} H: {}").set_scale(SCALE);
+        m_component.try_emplace("window_size", &window_size);
+    }
+    {
+        auto& frame_size = m_widget.add_child<Label>();
+        frame_size.set_text("FrameBuffer W: {} H: {}").set_scale(SCALE);
+        m_component.try_emplace("frame_buffer", &frame_size);
+    }
 }
 
 Widget& DebugCollector::get_widget() { return m_widget; }
@@ -139,6 +144,7 @@ bool DebugCollector::handle_event(const Event& e) {
 void DebugCollector::report(const std::string& name, std::string_view content) {
     auto t = m_component.find(name);
     if (t == m_component.end()) {
+        Logger::error("DebugCollector: Can't Find {}", name);
         return;
     }
     if (!t->second) {

src/gameplay/client_player.cpp

@@ -133,13 +133,9 @@ void ClientPlayer::update(float delta_time) {
     update_move(delta_time);
     update_lookup_block();
     place_block(delta_time);
-    DebugCollector::get().report("player_pos",
+    d_rep("player_pos", "x: {:.2f} y: {:.2f} z: {:.2f}", m_player_pos.x,
-                                 std::format("x: {:.2f} y: {:.2f} z: {:.2f}",
+          m_player_pos.y, m_player_pos.z);
-                                             m_player_pos.x, m_player_pos.y,
+    d_rep("speed", "Speed: {:.2} m/s", m_xz_speed);
-                                             m_player_pos.z));
-
-    DebugCollector::get().report("speed",
-                                 std::format("Speed: {:.2} m/s", m_xz_speed));
 }
 bool ClientPlayer::update_player_move_state(Key key, KeyAction action) {
     if (key == Key::W) {
@@ -334,7 +330,7 @@ void ClientPlayer::update_move(float delta_time) {
 
     // calculate speed
     if (m_move_state.forward || m_move_state.back || m_move_state.left ||
-        m_move_state.right || m_move_state.up) {
+        m_move_state.right) {
         direction = glm::vec3(0.0f, 0.0f, 0.0f);
         m_xz_speed += m_acceleration * delta_time;
         if (m_xz_speed > m_max_speed) {

src/render/renderer.cpp

@@ -202,7 +202,7 @@ void Renderer::render_lable(const Label& label) {
 
 void Renderer::render_image(const Image& image) {
     if (!image.texture()) {
-        Logger::error("Image id {} not set image!", image.id());
+        Logger::error("Image not set image!");
         return;
     }
     const auto& shader = get_shader("image");

src/render/world_renderer.cpp

@@ -546,8 +546,7 @@ void WorldRenderer::render_normal_block(const glm::mat4& model_mat,
             }
         }
     }
-    DebugCollector::get().report(
+    d_rep("rendered_chunk", "Rendered Chunk: {}", rendered_sum);
-        "rendered_chunk", "Rendered Chunk: " + std::to_string(rendered_sum));
 }
 
 void WorldRenderer::render_transparent_block(const glm::mat4& mv_mat,

src/ui/image.cpp

@@ -34,7 +34,7 @@ Image& Image::set_scale(float scale) {
 float Image::scale() const { return m_scale; }
 float Image::height() const {
     if (!m_texture) {
-        Logger::error("Image id {} not set image!", m_id);
+        Logger::error("Image not set image!");
         return 0.0f;
     }
     return m_height * m_scale;
@@ -42,7 +42,7 @@ float Image::height() const {
 
 float Image::width() const {
     if (!m_texture) {
-        Logger::error("Image id {} not set image!", m_id);
+        Logger::error("Image not set image!");
         return 0.0f;
     }
     return m_width * m_scale;

src/ui/label.cpp

@@ -3,7 +3,6 @@
 #include "Cubed/render/renderer.hpp"
 #include "Cubed/tools/font.hpp"
 namespace Cubed {
-Label::Label(const std::string& id, Widget* parent) : Widget(id, parent) {}
 Label::Label(Widget* parent) : Widget(parent) {}
 Label& Label::set_text(std::string_view text) {
     m_text.text = text;

src/ui/widget.cpp

@@ -3,8 +3,6 @@
 #include "Cubed/tools/log.hpp"
 
 namespace Cubed {
-Widget::Widget(const std::string& id, Widget* parent)
-    : m_parent(parent), m_id(id) {}
 Widget::Widget(Widget* parent) : m_parent(parent) {}
 void Widget::update(float dt) {
     on_update(dt);
@@ -127,7 +125,6 @@ float Widget::height() const {
 }
 
 glm::vec2 Widget::pos() const { return compute_position(); }
-const std::string& Widget::id() const { return m_id; }
 
 bool Widget::handle_key_event(const KeyEvent& e) {
     if (m_order == TraversalOrder::BACK_TO_FRONT) {