refactor(ui): extract common UI manager logic into base class

include/Cubed/ui/main_menu_ui_manager.hpp

@@ -1,14 +1,11 @@
 #pragma once
 
-#include "Cubed/input/event.hpp"
+#include "Cubed/ui/ui_manager.hpp"
-#include "Cubed/ui/widget.hpp"
 
-#include <memory>
-#include <unordered_map>
 namespace Cubed {
 class Renderer;
 class MainMenuScene;
-class MainMenuUIManager {
+class MainMenuUIManager : public UIManager {
 public:
     MainMenuUIManager(MainMenuScene& m_scene);
     MainMenuUIManager(const MainMenuUIManager&) = delete;
@@ -17,20 +14,9 @@ public:
     MainMenuUIManager& operator=(MainMenuUIManager&&) = delete;
     ~MainMenuUIManager();
 
-    void init();
+    void init() override;
-    void render(Renderer& renderer);
-    void update(float dt);
-
-    bool handle_event(const Event& e);
 
 private:
     MainMenuScene& m_scene;
-    std::unique_ptr<Widget> m_root_widget;
-    std::unordered_map<std::string, Widget*> m_widgets;
-    bool handle_mouse_move_event(const MouseMoveEvent& e);
-    bool handle_mouse_button_event(const MouseButtonEvent& e);
-    bool handle_window_resize_event(const WindowResizeEvent& e);
-    bool handle_mouse_wheel_event(const MouseWheelEvent& e);
-    bool handle_key_event(const KeyEvent& e);
 };
 } // namespace Cubed

include/Cubed/ui/ui_manager.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "Cubed/ui/widget.hpp"
+
+#include <memory>
+namespace Cubed {
+class UIManager {
+public:
+    UIManager() = default;
+    UIManager(const UIManager&) = delete;
+    UIManager(UIManager&&) = delete;
+    UIManager& operator=(const UIManager&) = delete;
+    UIManager& operator=(UIManager&&) = delete;
+    virtual ~UIManager();
+
+    virtual void init();
+
+    virtual void update(float dt);
+    virtual void render(Renderer& renderer);
+    virtual bool handle_event(const Event& e);
+
+    virtual Widget* get_widget(std::string name);
+
+protected:
+    std::unique_ptr<Widget> m_root_widget;
+    std::unordered_map<std::string, Widget*> m_widgets;
+    virtual bool handle_mouse_move_event(const MouseMoveEvent& e);
+    virtual bool handle_mouse_button_event(const MouseButtonEvent& e);
+    virtual bool handle_window_resize_event(const WindowResizeEvent& e);
+    virtual bool handle_mouse_wheel_event(const MouseWheelEvent& e);
+    virtual bool handle_key_event(const KeyEvent& e);
+};
+} // namespace Cubed

include/Cubed/ui/world_ui_manager.hpp

@@ -1,13 +1,11 @@
 #pragma once
 
-#include "Cubed/input/event.hpp"
+#include "Cubed/ui/ui_manager.hpp"
 #include "Cubed/ui/widget.hpp"
 
-#include <string>
-#include <unordered_map>
 namespace Cubed {
 class WorldScene;
-class WorldUIManager {
+class WorldUIManager : public UIManager {
 public:
     WorldUIManager(const WorldUIManager&) = delete;
     WorldUIManager(WorldUIManager&&) = delete;
@@ -17,18 +15,10 @@ public:
     WorldUIManager(WorldScene& scene);
     ~WorldUIManager();
 
-    void init();
+    void init() override;
-    void update(float dt);
+    void render(Renderer& renderer) override;
-    void render(Renderer& renderer);
-    bool handle_event(const Event& e);
 
 private:
     WorldScene& m_scene;
-    std::unordered_map<std::string, std::unique_ptr<Widget>> m_widgets;
-    bool handle_mouse_move_event(const MouseMoveEvent& e);
-    bool handle_mouse_button_event(const MouseButtonEvent& e);
-    bool handle_window_resize_event(const WindowResizeEvent& e);
-    bool handle_mouse_wheel_event(const MouseWheelEvent& e);
-    bool handle_key_event(const KeyEvent& e);
 };
 } // namespace Cubed

src/CMakeLists.txt

@@ -69,4 +69,5 @@ target_sources(${PROJECT_NAME}
         scene/main_menu_scene.cpp
         ui/column_layout.cpp
         ui/rect.cpp
+        ui/ui_manager.cpp
 )

src/ui/main_menu_ui_manager.cpp

@@ -58,88 +58,4 @@ void MainMenuUIManager::init() {
     m_root_widget = std::move(rect);
 }
 
-void MainMenuUIManager::update(float dt) { m_root_widget->update(dt); }
-
-void MainMenuUIManager::render(Renderer& renderer) {
-    renderer.begin_render_ui();
-
-    m_root_widget->render(renderer);
-
-    renderer.end_render_ui();
-}
-bool MainMenuUIManager::handle_event(const Event& e) {
-    return std::visit(
-        Overloaded{[this](const MouseMoveEvent& e) {
-                       if (handle_mouse_move_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const MouseButtonEvent& e) {
-                       if (handle_mouse_button_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const MouseWheelEvent& e) {
-                       if (handle_mouse_wheel_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const KeyEvent& e) {
-                       if (handle_key_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [](const TextInputEvent&) { return false; },
-                   [this](const WindowResizeEvent& e) {
-                       handle_window_resize_event(e);
-                       return false;
-                   },
-                   [](const FrameBufferResizeEvent&) { return false; }
-
-        },
-        e);
-}
-bool MainMenuUIManager::handle_mouse_move_event(const MouseMoveEvent& e) {
-    if (m_root_widget->handle_mouse_move_event(e)) {
-        return true;
-    }
-    return false;
-}
-bool MainMenuUIManager::handle_mouse_button_event(const MouseButtonEvent& e) {
-
-    if (m_root_widget->handle_mouse_button_event(e)) {
-        return true;
-    }
-
-    return false;
-}
-bool MainMenuUIManager::handle_window_resize_event(const WindowResizeEvent& e) {
-
-    if (m_root_widget->handle_window_resize_event(e)) {
-        return true;
-    }
-
-    return false;
-}
-bool MainMenuUIManager::handle_mouse_wheel_event(const MouseWheelEvent& e) {
-
-    if (m_root_widget->handle_mouse_wheel_event(e)) {
-        return true;
-    }
-
-    return false;
-}
-bool MainMenuUIManager::handle_key_event(const KeyEvent& e) {
-
-    if (m_root_widget->handle_key_event(e)) {
-        return true;
-    }
-
-    return false;
-}
-
 } // namespace Cubed

src/ui/ui_manager.cpp

@@ -0,0 +1,104 @@
+#include "Cubed/ui/ui_manager.hpp"
+
+#include "Cubed/render/renderer.hpp"
+
+namespace Cubed {
+
+UIManager::~UIManager() {}
+
+void UIManager::init() {}
+
+void UIManager::update(float dt) { m_root_widget->update(dt); }
+
+void UIManager::render(Renderer& renderer) {
+    renderer.begin_render_ui();
+
+    m_root_widget->render(renderer);
+
+    renderer.end_render_ui();
+}
+
+Widget* UIManager::get_widget(std::string name) {
+
+    auto it = m_widgets.find(name);
+    if (it != m_widgets.end()) {
+        return it->second;
+    }
+    return nullptr;
+}
+
+bool UIManager::handle_event(const Event& e) {
+    return std::visit(
+        Overloaded{[this](const MouseMoveEvent& e) {
+                       if (handle_mouse_move_event(e)) {
+                           return true;
+                       }
+                       return false;
+                   },
+                   [this](const MouseButtonEvent& e) {
+                       if (handle_mouse_button_event(e)) {
+                           return true;
+                       }
+                       return false;
+                   },
+                   [this](const MouseWheelEvent& e) {
+                       if (handle_mouse_wheel_event(e)) {
+                           return true;
+                       }
+                       return false;
+                   },
+                   [this](const KeyEvent& e) {
+                       if (handle_key_event(e)) {
+                           return true;
+                       }
+                       return false;
+                   },
+                   [](const TextInputEvent&) { return false; },
+                   [this](const WindowResizeEvent& e) {
+                       handle_window_resize_event(e);
+                       return false;
+                   },
+                   [](const FrameBufferResizeEvent&) { return false; }
+
+        },
+        e);
+}
+bool UIManager::handle_mouse_move_event(const MouseMoveEvent& e) {
+    if (m_root_widget->handle_mouse_move_event(e)) {
+        return true;
+    }
+    return false;
+}
+bool UIManager::handle_mouse_button_event(const MouseButtonEvent& e) {
+
+    if (m_root_widget->handle_mouse_button_event(e)) {
+        return true;
+    }
+
+    return false;
+}
+bool UIManager::handle_window_resize_event(const WindowResizeEvent& e) {
+
+    if (m_root_widget->handle_window_resize_event(e)) {
+        return true;
+    }
+
+    return false;
+}
+bool UIManager::handle_mouse_wheel_event(const MouseWheelEvent& e) {
+
+    if (m_root_widget->handle_mouse_wheel_event(e)) {
+        return true;
+    }
+
+    return false;
+}
+bool UIManager::handle_key_event(const KeyEvent& e) {
+
+    if (m_root_widget->handle_key_event(e)) {
+        return true;
+    }
+
+    return false;
+}
+} // namespace Cubed

src/ui/world_ui_manager.cpp

@@ -20,101 +20,16 @@ void WorldUIManager::init() {
                                renderer.window_height());
     crosshair->set_anchor(Anchor::CENTER);
     crosshair->set_scale(3.0f);
-    m_widgets.try_emplace("crosshair", std::move(crosshair));
+    m_widgets.try_emplace("crosshair", crosshair.get());
-}
+    m_root_widget = std::move(crosshair);
-void WorldUIManager::update(float dt) {
-
-    for (auto& w : m_widgets) {
-        w.second->update(dt);
-    }
 }
 void WorldUIManager::render(Renderer& renderer) {
     renderer.begin_render_ui();
 
     auto& widget = DebugCollector::get().get_widget();
     widget.render(renderer);
-    for (auto& widget : m_widgets) {
+    m_root_widget->render(renderer);
-        widget.second->render(renderer);
-    }
-
     renderer.end_render_ui();
 }
-bool WorldUIManager::handle_event(const Event& e) {
-    return std::visit(
-        Overloaded{[this](const MouseMoveEvent& e) {
-                       if (handle_mouse_move_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const MouseButtonEvent& e) {
-                       if (handle_mouse_button_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const MouseWheelEvent& e) {
-                       if (handle_mouse_wheel_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [this](const KeyEvent& e) {
-                       if (handle_key_event(e)) {
-                           return true;
-                       }
-                       return false;
-                   },
-                   [](const TextInputEvent&) { return false; },
-                   [this](const WindowResizeEvent& e) {
-                       handle_window_resize_event(e);
-                       return false;
-                   },
-                   [](const FrameBufferResizeEvent&) { return false; }
-
-        },
-        e);
-}
-bool WorldUIManager::handle_mouse_move_event(const MouseMoveEvent& e) {
-    for (auto& w : m_widgets) {
-        if (w.second->handle_mouse_move_event(e)) {
-            return true;
-        }
-    }
-    return false;
-}
-bool WorldUIManager::handle_mouse_button_event(const MouseButtonEvent& e) {
-    for (auto& w : m_widgets) {
-        if (w.second->handle_mouse_button_event(e)) {
-            return true;
-        }
-    }
-    return false;
-}
-bool WorldUIManager::handle_window_resize_event(const WindowResizeEvent& e) {
-    for (auto& w : m_widgets) {
-        if (w.second->handle_window_resize_event(e)) {
-            return true;
-        }
-    }
-    return false;
-}
-bool WorldUIManager::handle_mouse_wheel_event(const MouseWheelEvent& e) {
-    for (auto& w : m_widgets) {
-        if (w.second->handle_mouse_wheel_event(e)) {
-            return true;
-        }
-    }
-    return false;
-}
-bool WorldUIManager::handle_key_event(const KeyEvent& e) {
-    for (auto& w : m_widgets) {
-        if (w.second->handle_key_event(e)) {
-            return true;
-        }
-    }
-
-    return false;
-}
 
 } // namespace Cubed