ui: add main menu scene and interactive button widget

- Implement MainMenuScene with a "Start Game" button that pushes the WorldScene.
- Extend Button class with background/foreground, hover detection, and size queries.
- Add virtual width/height and event handlers to Widget base class.
- Update WorldUIManager to propagate mouse move events.
- Adjust Window mouse mode based on game running state.

include/Cubed/scene/main_menu_scene.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Cubed/scene/scene.hpp"
+#include "Cubed/ui/main_menu_ui_manager.hpp"
+namespace Cubed {
+class SceneManager;
+class MainMenuScene : public Scene {
+public:
+    MainMenuScene(const MainMenuScene&) = delete;
+    MainMenuScene(MainMenuScene&&) = delete;
+    MainMenuScene& operator=(const MainMenuScene&) = delete;
+    MainMenuScene& operator=(MainMenuScene&&) = delete;
+    MainMenuScene(SceneManager& scene_manager);
+    ~MainMenuScene();
+
+    void update(float dt) override;
+    void render(Renderer& renderer) override;
+    bool handle_event(const Event& e) override;
+    void on_enter() override;
+    void on_leave() override;
+
+    SceneManager& scene_manager();
+
+private:
+    SceneManager& m_scene_manager;
+    MainMenuUIManager m_ui_manager;
+};
+} // namespace Cubed

include/Cubed/ui/button.hpp

@@ -9,11 +9,48 @@ class Button : public Widget {
 public:
     Button();
 
+    Button(const Button&) = delete;
+    Button(Button&&) = delete;
+    Button& operator=(const Button&) = delete;
+    Button& operator=(Button&&) = delete;
+
+    void render(Renderer& renderer) override;
+    void update(float dt) override;
+
+    bool handle_mouse_move_event(const MouseMoveEvent& e) override;
+    bool handle_mouse_button_event(const MouseButtonEvent& e) override;
+
+    Widget& set_position(const glm::vec2& pos) override;
+    Widget& set_position(float x, float y) override;
+
+    float width() const override;
+    float height() const override;
+
     template <typename F> Button& set_clicked(F&& f) {
-        m_clicked = std::move(f);
+        m_clicked = std::forward<F>(f);
+        return *this;
+    }
+
+    template <typename T, typename... Args> T& set_background(Args&&... args) {
+        auto w = std::make_unique<T>(std::forward<Args>(args)...);
+        T& ref = *w;
+        m_background = std::move(w);
+        return ref;
+    }
+
+    template <typename T, typename... Args> T& set_foreground(Args&&... args) {
+        auto w = std::make_unique<T>(std::forward<Args>(args)...);
+        T& ref = *w;
+        m_foreground = std::move(w);
+        return ref;
     }
 
 private:
     std::function<void()> m_clicked;
+    std::unique_ptr<Widget> m_background;
+    std::unique_ptr<Widget> m_foreground;
+    bool m_hovered = false;
+    glm::vec2 m_min_pos;
+    glm::vec2 m_max_pos;
 };
 } // namespace Cubed

include/Cubed/ui/image.hpp

@@ -13,8 +13,8 @@ public:
     void render(Renderer& renderer) override;
 
     Image& set_image(const std::string& path, TextureManager& texture_manager);
-    float width() const;
-    float height() const;
+    float width() const override;
+    float height() const override;
     const Texture* texture() const;
 
 private:

include/Cubed/ui/label.hpp

@@ -12,6 +12,7 @@ public:
     Label& operator=(Label&&) = delete;
 
     Label(const std::string& id);
+    Label();
     virtual ~Label() = default;
 
     Label& set_text(std::string_view text);

include/Cubed/ui/main_menu_ui_manager.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "Cubed/input/event.hpp"
+#include "Cubed/ui/widget.hpp"
+
+#include <memory>
+#include <unordered_map>
+namespace Cubed {
+class Renderer;
+class MainMenuScene;
+class MainMenuUIManager {
+public:
+    MainMenuUIManager(MainMenuScene& m_scene);
+    MainMenuUIManager(const MainMenuUIManager&) = delete;
+    MainMenuUIManager(MainMenuUIManager&&) = delete;
+    MainMenuUIManager& operator=(const MainMenuUIManager&) = delete;
+    MainMenuUIManager& operator=(MainMenuUIManager&&) = delete;
+    ~MainMenuUIManager();
+
+    void init();
+    void render(Renderer& renderer);
+    void update(float dt);
+
+    bool handle_event(const Event& e);
+
+private:
+    MainMenuScene& 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

include/Cubed/ui/widget.hpp

@@ -1,10 +1,12 @@
 #pragma once
+#include "Cubed/input/event.hpp"
 #include "glm/ext/vector_float2.hpp"
 
 #include <memory>
 #include <vector>
 namespace Cubed {
 class Renderer;
+
 class Widget {
 
 public:
@@ -17,9 +19,17 @@ public:
     virtual Widget& set_position(const glm::vec2& pos);
     virtual Widget& set_position(float x, float y);
     virtual Widget& set_scale(float scale);
+    virtual float width() const;
+    virtual float height() const;
     virtual const glm::vec2& pos() const;
     virtual float scale() const;
 
+    virtual bool handle_key_event(const KeyEvent& e);
+    virtual bool handle_mouse_button_event(const MouseButtonEvent& e);
+    virtual bool handle_mouse_wheel_event(const MouseWheelEvent& e);
+    virtual bool handle_window_resize_event(const WindowResizeEvent& e);
+    virtual bool handle_mouse_move_event(const MouseMoveEvent& e);
+
     template <typename T, typename... Args> T& add_child(Args&&... args) {
         auto widget = std::make_unique<T>(std::forward<Args>(args)...);
         T& ref = *widget;

include/Cubed/ui/world_ui_manager.hpp

@@ -25,7 +25,7 @@ public:
 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);

include/Cubed/window.hpp

@@ -30,9 +30,12 @@ public:
     void set_camera(Camera* camera);
     Camera* camera();
 
+    void set_game_running(bool running);
+
 private:
     bool m_mouse_enable = false;
     bool m_imgui_init = false;
+    bool m_game_running = false;
     GLFWwindow* m_window;
     int m_window_width;
     int m_window_height;