refactor(scene): dispatch events via typed handlers and move pause toggle to WorldScene

include/Cubed/scene/scene.hpp

@@ -20,5 +20,20 @@ public:
     virtual bool handle_event(const Event& e) = 0;
     virtual void on_enter() {};
     virtual void on_leave() {};
+
+protected:
+    virtual bool handle_mouse_move_event(const MouseMoveEvent&) {
+        return false;
+    }
+    virtual bool handle_mouse_button_event(const MouseButtonEvent&) {
+        return false;
+    }
+    virtual bool handle_window_resize_event(const WindowResizeEvent&) {
+        return false;
+    }
+    virtual bool handle_mouse_wheel_event(const MouseWheelEvent&) {
+        return false;
+    }
+    virtual bool handle_key_event(const KeyEvent&) { return false; }
 };
 } // namespace Cubed

include/Cubed/scene/world_scene.hpp

@@ -33,6 +33,12 @@ public:
     void set_pause(bool pause);
 
 private:
+    bool handle_mouse_move_event(const MouseMoveEvent& e) override;
+    bool handle_mouse_button_event(const MouseButtonEvent& e) override;
+    bool handle_window_resize_event(const WindowResizeEvent& e) override;
+    bool handle_mouse_wheel_event(const MouseWheelEvent& e) override;
+    bool handle_key_event(const KeyEvent& e) override;
+
     SceneManager& m_scene_manager;
     DevPanel m_dev_panel;
     Camera m_camera;

include/Cubed/ui/pasue_menu_ui_manager.hpp

@@ -14,7 +14,5 @@ public:
 
 private:
     WorldScene& m_scene;
-
-    bool handle_key_event(const KeyEvent& e) override;
 };
 } // namespace Cubed

include/Cubed/ui/ui_manager.hpp

@@ -21,13 +21,14 @@ public:
 
     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);
+
+protected:
+    std::unique_ptr<Widget> m_root_widget;
+    std::unordered_map<std::string, Widget*> m_widgets;
 };
 } // namespace Cubed

src/gameplay/client_player.cpp

@@ -4,7 +4,6 @@
 #include "Cubed/config.hpp"
 #include "Cubed/debug_collector.hpp"
 #include "Cubed/gameplay/client_world.hpp"
-#include "Cubed/scene/world_scene.hpp"
 
 namespace {} // namespace
 
@@ -584,11 +583,6 @@ bool ClientPlayer::handle_mouse_button_event(const MouseButtonEvent& e) {
 
 bool ClientPlayer::handle_key_event(const KeyEvent& e) {
 
-    if (e.key == Key::ESCAPE && e.action == KeyAction::PRESS) {
-        m_world.world_scene().set_pause(true);
-        return true;
-    }
-
     if (update_player_move_state(e.key, e.action)) {
         return true;
     }

src/scene/world_scene.cpp

@@ -56,25 +56,41 @@ void WorldScene::render(Renderer& renderer) {
     }
 }
 bool WorldScene::handle_event(const Event& e) {
-    if (m_paused) {
-
-        if (m_pasue_menu.handle_event(e)) {
 
+    return std::visit(
+        Overloaded{[this](const MouseMoveEvent& e) {
+                       if (handle_mouse_move_event(e)) {
                            return true;
                        }
-    } else {
-        if (m_ui_manager.handle_event(e)) {
-            return true;
-        }
-        if (m_camera.handle_event(e)) {
-            return true;
-        }
-        // world event needs to be processed last
-        if (m_client_world.handle_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);
 }
 void WorldScene::on_enter() {
 
@@ -109,6 +125,109 @@ void WorldScene::on_leave() {
     }
 }
 
+bool WorldScene::handle_mouse_move_event(const MouseMoveEvent& e) {
+    if (m_paused) {
+        if (m_pasue_menu.handle_event(e)) {
+            return true;
+        }
+    } else {
+        if (m_ui_manager.handle_event(e)) {
+            return true;
+        }
+        if (m_camera.handle_event(e)) {
+            return true;
+        }
+        // world event needs to be processed last
+        if (m_client_world.handle_event(e)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+bool WorldScene::handle_mouse_button_event(const MouseButtonEvent& e) {
+    if (m_paused) {
+        if (m_pasue_menu.handle_event(e)) {
+            return true;
+        }
+    } else {
+        if (m_ui_manager.handle_event(e)) {
+            return true;
+        }
+        if (m_camera.handle_event(e)) {
+            return true;
+        }
+        // world event needs to be processed last
+        if (m_client_world.handle_event(e)) {
+            return true;
+        }
+    }
+    return false;
+}
+bool WorldScene::handle_window_resize_event(const WindowResizeEvent& e) {
+
+    if (m_pasue_menu.handle_event(e)) {
+        return true;
+    }
+    if (m_ui_manager.handle_event(e)) {
+        return true;
+    }
+    if (m_camera.handle_event(e)) {
+        return true;
+    }
+    // world event needs to be processed last
+    if (m_client_world.handle_event(e)) {
+        return true;
+    }
+
+    return false;
+}
+bool WorldScene::handle_mouse_wheel_event(const MouseWheelEvent& e) {
+    if (m_paused) {
+        if (m_pasue_menu.handle_event(e)) {
+            return true;
+        }
+    } else {
+        if (m_ui_manager.handle_event(e)) {
+            return true;
+        }
+        if (m_camera.handle_event(e)) {
+            return true;
+        }
+        // world event needs to be processed last
+        if (m_client_world.handle_event(e)) {
+            return true;
+        }
+    }
+    return false;
+}
+bool WorldScene::handle_key_event(const KeyEvent& e) {
+
+    if (e.key == Key::ESCAPE && e.action == KeyAction::PRESS) {
+        bool pasued = pause();
+        pasued = !pasued;
+        set_pause(pasued);
+        return true;
+    }
+    if (m_paused) {
+        if (m_pasue_menu.handle_event(e)) {
+            return true;
+        }
+    } else {
+        if (m_ui_manager.handle_event(e)) {
+            return true;
+        }
+        if (m_camera.handle_event(e)) {
+            return true;
+        }
+        // world event needs to be processed last
+        if (m_client_world.handle_event(e)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 Camera& WorldScene::camera() { return m_camera; }
 SceneManager& WorldScene::scene_manager() { return m_scene_manager; }
 ClientWorld& WorldScene::client_world() { return m_client_world; }

src/ui/pause_menu_ui_manager.cpp

@@ -30,12 +30,4 @@ void PauseMenuUIManager::init() {
     m_root_widget = std::move(rect);
 }
 
-bool PauseMenuUIManager::handle_key_event(const KeyEvent& e) {
-    if (e.key == Key::ESCAPE && e.action == KeyAction::PRESS) {
-        m_scene.set_pause(false);
-        return true;
-    }
-    return UIManager::handle_key_event(e);
-}
-
 } // namespace Cubed