refactor: add framebuffer resize event and separate UI management

include/Cubed/app.hpp

@@ -25,6 +25,8 @@ public:
     static void window_focus_callback(GLFWwindow* window, int focused);
     static void window_reshape_callback(GLFWwindow* window, int new_width,
                                         int new_height);
+    static void framebuffer_size_callback(GLFWwindow* window, int new_width,
+                                          int new_height);
     static void mouse_scroll_callback(GLFWwindow* window, double xoffset,
                                       double yoffset);
     static void cursor_enter_callback(GLFWwindow* window, int entered);

include/Cubed/input/event.hpp

@@ -41,8 +41,17 @@ struct TextInputEvent {
     TextInputEvent(std::string t) : text(std::move(t)) {}
 };
 
-using Event = std::variant<MouseMoveEvent, MouseButtonEvent, MouseWheelEvent,
+struct WindowResizeEvent {
-                           KeyEvent, TextInputEvent>;
+    int width;
+    int height;
+};
+struct FrameBufferResizeEvent {
+    int width;
+    int height;
+};
+using Event =
+    std::variant<MouseMoveEvent, MouseButtonEvent, MouseWheelEvent, KeyEvent,
+                 TextInputEvent, WindowResizeEvent, FrameBufferResizeEvent>;
 
 template <class... T> struct Overloaded : T... {
     using T::operator()...;

include/Cubed/render/renderer.hpp

@@ -2,6 +2,7 @@
 
 #include "Cubed/config.hpp"
 #include "Cubed/constants.hpp"
+#include "Cubed/input/event.hpp"
 #include "Cubed/primitive_data.hpp"
 #include "Cubed/render/player_renderer.hpp"
 #include "Cubed/render/shader_manager.hpp"
@@ -29,15 +30,16 @@ public:
     const Shader& get_shader(const std::string& name) const;
     void begin_frame();
     void end_frame();
-    void render();
     void render_world(ClientWorld& world);
     void render_lable(const Label& label);
     void render_image(const Image& image);
 
+    void begin_render_ui();
+    void end_render_ui();
+
     void update(float delta_time);
     void update_fov(float fov);
-    void update_proj_matrix(float aspect, float width, float height);
+
-    void updata_framebuffer(int width, int height);
     float& ambient_strength();
 
     bool& discard_transparent();
@@ -65,13 +67,17 @@ public:
     const TextureManager& texture_mamger() const;
     float delta_time() const;
 
-    float height() const;
+    float window_height() const;
-    float width() const;
+    float window_width() const;
+    float frame_height() const;
+    float frame_width() const;
     const glm::mat4& p_mat() const;
 
     const std::vector<VertexArray>& vao() const;
     void render_dev_panel(DevPanel& dev_panel);
 
+    bool handle_event(const Event& e);
+
 private:
     TextureManager& m_texture_manager;
 
@@ -82,8 +88,11 @@ private:
 
     float m_delta_time = 0.0f;
 
-    float m_width = 0.0f;
+    float m_frame_width = 0.0f;
-    float m_height = 0.0f;
+    float m_frame_height = 0.0f;
+
+    float m_window_width = 0.0f;
+    float m_window_height = 0.0f;
 
     glm::mat4 m_world_proj_matrix;
 
@@ -94,8 +103,6 @@ private:
     std::unique_ptr<VertexBuffer> m_player_vbo;
     std::unique_ptr<VertexBuffer> m_quad_vbo;
 
-    std::unique_ptr<Image> m_crosshair_image;
-
     glm::mat4 m_ui_proj_matrix;
     ShaderManager m_shaders;
 
@@ -111,11 +118,12 @@ private:
 
     WorldRenderer m_world_renderer;
     Config& m_config;
+
+    bool handle_window_resize_event(const WindowResizeEvent& e);
+    bool handle_frame_buffer_resize_event(const FrameBufferResizeEvent& e);
+    void updata_framebuffer(int width, int height);
     void init_quad();
     void init_text();
-
-    void render_ui();
-    void render_crosshair();
 };
 
 } // namespace Cubed

include/Cubed/scene/world_scene.hpp

@@ -4,6 +4,7 @@
 #include "Cubed/dev_panel.hpp"
 #include "Cubed/gameplay/client_world.hpp"
 #include "Cubed/scene/scene.hpp"
+#include "Cubed/ui/world_ui_manager.hpp"
 namespace Cubed {
 class SceneManager;
 class WorldScene : public Scene {
@@ -32,7 +33,7 @@ private:
     Camera m_camera;
     std::shared_ptr<NetworkClient> m_client;
     ClientWorld m_client_world;
-
+    WorldUIManager m_ui_manager;
     const Argument& m_argument;
 };
 } // namespace Cubed

include/Cubed/ui/ui_manager.hpp

@@ -1,13 +0,0 @@
-#pragma once
-
-namespace Cubed {
-class UIManager {
-public:
-    UIManager(const UIManager&) = delete;
-    UIManager(UIManager&&) = delete;
-    UIManager& operator=(const UIManager&) = delete;
-    UIManager& operator=(UIManager&&) = delete;
-
-private:
-};
-} // namespace Cubed

include/Cubed/ui/world_ui_manager.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Cubed/input/event.hpp"
+#include "Cubed/ui/widget.hpp"
+
+#include <string>
+#include <unordered_map>
+namespace Cubed {
+class WorldScene;
+class WorldUIManager {
+public:
+    WorldUIManager(const WorldUIManager&) = delete;
+    WorldUIManager(WorldUIManager&&) = delete;
+    WorldUIManager& operator=(const WorldUIManager&) = delete;
+    WorldUIManager& operator=(WorldUIManager&&) = delete;
+
+    WorldUIManager(WorldScene& scene);
+    ~WorldUIManager();
+
+    void init();
+    void update(float dt);
+    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_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/window.hpp

@@ -10,7 +10,7 @@ class Camera;
 class Renderer;
 class Window {
 public:
-    Window(Renderer& renderer, Config& config);
+    Window(Config& config);
     ~Window();
 
     bool is_mouse_enable() const;
@@ -18,7 +18,7 @@ public:
     GLFWwindow* get_glfw_window();
     void init();
     void imgui_init();
-    void update_viewport();
+
     // end of frame to reload!
     bool handle_event(const Event& e);
 
@@ -33,14 +33,13 @@ public:
 private:
     bool m_mouse_enable = false;
     bool m_imgui_init = false;
-    float m_aspect;
     GLFWwindow* m_window;
-    int m_width;
+    int m_window_width;
-    int m_height;
+    int m_window_height;
-    Renderer& m_renderer;
     Config& m_config;
     Camera* m_camera = nullptr;
     bool handle_key_event(const KeyEvent& e);
+    bool handle_window_resize_event(const WindowResizeEvent& e);
     bool handle_mouse_button_event(const MouseButtonEvent& e);
 };
 

src/CMakeLists.txt

@@ -65,4 +65,5 @@ target_sources(${PROJECT_NAME}
         ui/button.cpp
         scene/world_scene.cpp
         scene/scene_manager.cpp
+        ui/world_ui_manager.cpp
 )

src/app.cpp

@@ -17,8 +17,8 @@ App::App()
 
     : m_game_config(ASSETS_PATH "config.toml"),
       m_texture_manager(m_game_config), m_audio(m_game_config),
-      m_renderer(m_texture_manager, m_game_config),
+      m_renderer(m_texture_manager, m_game_config), m_window(m_game_config),
-      m_window(m_renderer, m_game_config), m_scene_manager(*this) {}
+      m_scene_manager(*this) {}
 
 App::~App() {}
 void App::cursor_position_callback(GLFWwindow* window, double xpos,
@@ -56,6 +56,8 @@ void App::init(int argc, char** argv) {
                                window_focus_callback);
     glfwSetWindowSizeCallback(m_window.get_glfw_window(),
                               window_reshape_callback);
+    glfwSetFramebufferSizeCallback(m_window.get_glfw_window(),
+                                   framebuffer_size_callback);
     glfwSetKeyCallback(m_window.get_glfw_window(), key_callback);
     glfwSetScrollCallback(m_window.get_glfw_window(), mouse_scroll_callback);
     glfwSetCursorEnterCallback(m_window.get_glfw_window(),
@@ -68,7 +70,6 @@ void App::init(int argc, char** argv) {
     BlockManager::init();
     m_renderer.init(m_argument.debug_on);
     Logger::info("Renderer Init Success");
-    m_window.update_viewport();
     // MapTable::init_map();
     m_texture_manager.init_texture();
     Logger::info("Texture Load Success");
@@ -77,6 +78,18 @@ void App::init(int argc, char** argv) {
     }
 
     m_scene_manager.request_push(SceneType::WORLD);
+
+    {
+        int w, h;
+        glfwGetWindowSize(m_window.get_glfw_window(), &w, &h);
+        window_reshape_callback(m_window.get_glfw_window(), w, h);
+    }
+
+    {
+        int w, h;
+        glfwGetFramebufferSize(m_window.get_glfw_window(), &w, &h);
+        framebuffer_size_callback(m_window.get_glfw_window(), w, h);
+    }
 }
 
 void App::handle_argument(int argc, char** argv) {
@@ -582,13 +595,22 @@ void App::window_focus_callback(GLFWwindow* window, int focused) {
     }
 }
 
-void App::window_reshape_callback(GLFWwindow* window, int, int) {
+void App::window_reshape_callback(GLFWwindow* window, int width, int height) {
 
     App* app = static_cast<App*>(glfwGetWindowUserPointer(window));
     ASSERT_MSG(app, "nullptr");
-    app->m_window.update_viewport();
-}
 
+    app->dispatch_event(WindowResizeEvent{width, height});
+
+    Logger::info("Window Reshape W: {} H: {}", width, height);
+}
+void App::framebuffer_size_callback(GLFWwindow* window, int width, int height) {
+    App* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    ASSERT_MSG(app, "nullptr");
+    app->dispatch_event(FrameBufferResizeEvent{width, height});
+
+    Logger::info("Frame Buffer Reshape W: {} H: {}", width, height);
+}
 void App::mouse_scroll_callback(GLFWwindow* window, double xoffset,
                                 double yoffset) {
     ImGuiIO& io = ImGui::GetIO();
@@ -629,7 +651,6 @@ void App::render() {
     }
     m_renderer.begin_frame();
     m_scene_manager.render(m_renderer);
-    m_renderer.render();
     m_renderer.end_frame();
     glfwSwapBuffers(m_window.get_glfw_window());
 }
@@ -652,6 +673,14 @@ void App::run() {
 // static Gait player_gait = Gait::WALK;
 void App::update() {
     glfwPollEvents();
+
+    int w, h;
+    glfwGetFramebufferSize(m_window.get_glfw_window(), &w, &h);
+
+    if (w != m_renderer.frame_width() || h != m_renderer.frame_height()) {
+        dispatch_event(FrameBufferResizeEvent{w, h});
+    }
+
     current_time = glfwGetTime();
     dt = current_time - last_time;
     last_time = current_time;
@@ -682,9 +711,15 @@ void App::dispatch_event(const Event& e) {
     if (m_window.handle_event(e)) {
         return;
     }
+
     if (m_texture_manager.handle_event(e)) {
         return;
     }
+
+    if (m_renderer.handle_event(e)) {
+        return;
+    }
+
     if (m_scene_manager.handle_event(e)) {
         return;
     }

src/camera.cpp

@@ -124,15 +124,20 @@ bool Camera::handle_event(const Event& e) {
 
                        return false;
                    },
-                   [](const MouseButtonEvent& e) { return false; },
+                   [](const MouseButtonEvent&) { return false; },
-                   [](const MouseWheelEvent& e) { return false; },
+                   [](const MouseWheelEvent&) { return false; },
                    [this](const KeyEvent& e) {
                        if (handle_key_event(e)) {
                            return true;
                        }
                        return false;
                    },
-                   [](const TextInputEvent& e) { return false; }},
+                   [](const TextInputEvent&) { return false; },
+                   [](const WindowResizeEvent&) { return false; },
+                   [](const FrameBufferResizeEvent&) { return false; }
+
+        } // namespace Cubed
+        ,
         e);
 }
 

src/gameplay/client_world.cpp

@@ -914,7 +914,7 @@ bool ClientWorld::handle_event(const Event& e) {
                        }
                        return false;
                    },
-                   [](const MouseMoveEvent& e) { return false; },
+                   [](const MouseMoveEvent&) { return false; },
                    [this](const MouseWheelEvent& e) {
                        if (m_player.handle_mouse_wheel_event(e)) {
                            return true;
@@ -928,7 +928,9 @@ bool ClientWorld::handle_event(const Event& e) {
 
                        return false;
                    },
-                   [](const TextInputEvent& e) { return false; }
+                   [](const TextInputEvent&) { return false; },
+                   [](const WindowResizeEvent&) { return false; },
+                   [](const FrameBufferResizeEvent&) { return false; }
 
         },
         e);

src/render/renderer.cpp

@@ -114,12 +114,6 @@ void Renderer::init(bool debug_on) {
     VertexArray::unbind();
     VertexBuffer::unbind();
 
-    m_crosshair_image = std::make_unique<Image>();
-    m_crosshair_image->set_image("texture/ui/0.png", m_texture_manager);
-    m_crosshair_image
-        ->set_position(m_width / 2 + m_crosshair_image->width() / 2,
-                       m_height / 2 + m_crosshair_image->height() / 2)
-        .set_scale(3.0f);
     m_init = true;
 }
 
@@ -149,17 +143,14 @@ void Renderer::begin_frame() {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 void Renderer::end_frame() {}
-void Renderer::render() {
 
+void Renderer::begin_render_ui() {
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glDisable(GL_DEPTH_TEST);
-
-    render_ui();
-
-    glEnable(GL_DEPTH_TEST);
 }
+void Renderer::end_render_ui() { glEnable(GL_DEPTH_TEST); }
 
 void Renderer::render_world(ClientWorld& world) {
     m_world_renderer.render(world);
@@ -213,15 +204,6 @@ void Renderer::render_image(const Image& image) {
     Tools::check_opengl_error();
 }
 
-void Renderer::render_ui() {
-
-    auto& widget = DebugCollector::get().get_widget();
-    widget.render(*this);
-    render_crosshair();
-}
-
-void Renderer::render_crosshair() { m_crosshair_image->render(*this); }
-
 void Renderer::update(float delta_time) { m_delta_time = delta_time; }
 
 void Renderer::update_fov(float fov) {
@@ -231,19 +213,6 @@ void Renderer::update_fov(float fov) {
         glm::perspective(glm::radians(fov), m_aspect, NEAR_PLANE, FAR_PLANE);
 }
 
-void Renderer::update_proj_matrix(float aspect, float width, float height) {
-    m_aspect = aspect;
-
-    m_world_proj_matrix =
-        glm::perspective(glm::radians(m_fov), aspect, NEAR_PLANE, FAR_PLANE);
-
-    m_ui_proj_matrix = glm::ortho(0.0f, width, height, 0.0f, -1.0f, 1.0f);
-    // scale and then translate
-    m_crosshair_image->set_position(
-        width / 2.0f + m_crosshair_image->width() / 2,
-        height / 2.0f + m_crosshair_image->height() / 2);
-}
-
 void Renderer::updata_framebuffer(int width, int height) {
     if (width <= 0 || height <= 0)
         return;
@@ -251,9 +220,6 @@ void Renderer::updata_framebuffer(int width, int height) {
     m_world_renderer.updata_framebuffer(width, height);
 
     FrameBuffer::unbind();
-
-    m_width = width;
-    m_height = height;
 }
 
 void Renderer::render_dev_panel(DevPanel& dev_panel) {
@@ -264,6 +230,45 @@ void Renderer::render_dev_panel(DevPanel& dev_panel) {
     glEnable(GL_DEPTH_TEST);
 }
 
+bool Renderer::handle_event(const Event& e) {
+    return std::visit(Overloaded{[](const MouseMoveEvent&) { return false; },
+                                 [](const MouseButtonEvent&) { return false; },
+                                 [](const MouseWheelEvent&) { return false; },
+                                 [](const KeyEvent&) { return false; },
+                                 [](const TextInputEvent&) { return false; },
+                                 [this](const WindowResizeEvent& e) {
+                                     handle_window_resize_event(e);
+                                     return false;
+                                 },
+                                 [this](const FrameBufferResizeEvent& e) {
+                                     handle_frame_buffer_resize_event(e);
+                                     return false;
+                                 }
+
+                      },
+                      e);
+}
+bool Renderer::handle_window_resize_event(const WindowResizeEvent& e) {
+    m_window_width = static_cast<float>(e.width);
+    m_window_height = static_cast<float>(e.height);
+    m_ui_proj_matrix =
+        glm::ortho(0.0f, m_window_width, m_window_height, 0.0f, -1.0f, 1.0f);
+    return false;
+}
+bool Renderer::handle_frame_buffer_resize_event(
+    const FrameBufferResizeEvent& e) {
+    int frame_height = e.height;
+    int frame_width = e.width;
+    m_frame_width = static_cast<float>(e.width);
+    m_frame_height = static_cast<float>(e.height);
+    m_aspect = m_frame_width / m_frame_height;
+    glViewport(0, 0, frame_width, frame_height);
+    m_world_proj_matrix =
+        glm::perspective(glm::radians(m_fov), m_aspect, NEAR_PLANE, FAR_PLANE);
+    updata_framebuffer(frame_width, frame_height);
+    return false;
+}
+
 float& Renderer::ambient_strength() {
     return m_world_renderer.ambient_strength();
 }
@@ -310,8 +315,10 @@ const TextureManager& Renderer::texture_mamger() const {
 
 float Renderer::delta_time() const { return m_delta_time; }
 
-float Renderer::height() const { return m_height; }
+float Renderer::window_height() const { return m_window_height; }
-float Renderer::width() const { return m_width; }
+float Renderer::window_width() const { return m_window_width; }
+float Renderer::frame_height() const { return m_frame_height; }
+float Renderer::frame_width() const { return m_frame_width; }
 const glm::mat4& Renderer::p_mat() const { return m_world_proj_matrix; }
 const std::vector<VertexArray>& Renderer::vao() const { return m_vao; }
 } // namespace Cubed

src/render/world_renderer.cpp

@@ -215,8 +215,8 @@ void WorldRenderer::render_world(ClientWorld& world) {
 
     // shader map
 
-    auto m_height = m_renderer.height();
+    auto height = m_renderer.frame_height();
-    auto m_width = m_renderer.width();
+    auto width = m_renderer.frame_width();
 
     glm::mat4 model_mat =
         glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
@@ -232,7 +232,7 @@ void WorldRenderer::render_world(ClientWorld& world) {
     m_world_fbo->bind();
 
     glCullFace(GL_BACK);
-    glViewport(0, 0, m_width, m_height);
+    glViewport(0, 0, width, height);
 
     render_normal_block(model_mat, mv_mat, norm_mat, world);
 
@@ -241,7 +241,7 @@ void WorldRenderer::render_world(ClientWorld& world) {
 
     m_oit_fbo->bind(FrameBufferType::DRAW_FRAMEBUFFER);
 
-    glBlitFramebuffer(0, 0, m_width, m_height, 0, 0, m_width, m_height,
+    glBlitFramebuffer(0, 0, width, height, 0, 0, width, height,
                       GL_DEPTH_BUFFER_BIT, GL_NEAREST);
     m_oit_fbo->bind(FrameBufferType::DRAW_FRAMEBUFFER);
 

src/scene/scene_manager.cpp

@@ -22,6 +22,9 @@ void SceneManager::render(Renderer& renderer) {
 }
 
 bool SceneManager::handle_event(const Event& e) {
+    if (m_scenes.empty()) {
+        return false;
+    }
     return m_scenes.top()->handle_event(e);
 }
 

src/scene/world_scene.cpp

@@ -8,7 +8,7 @@ WorldScene::WorldScene(SceneManager& scene_manager)
     : m_scene_manager(scene_manager), m_dev_panel(*this),
       m_client_world(scene_manager.app().audio(), scene_manager.app().config(),
                      *this),
-      m_argument(scene_manager.app().argument()) {}
+      m_ui_manager(*this), m_argument(scene_manager.app().argument()) {}
 
 WorldScene::~WorldScene() {
     if (m_client) {
@@ -22,6 +22,7 @@ void WorldScene::update(float dt) {
     m_client_world.get_audio().update_listener(m_camera.get_camera_pos(),
                                                m_camera.get_camera_front(),
                                                glm::vec3(0, 1, 0));
+
     /*
     const auto& player = m_client_world.get_player();
     if (player_gait != player.get_gait()) {
@@ -34,16 +35,21 @@ void WorldScene::update(float dt) {
             m_renderer.update_fov(fov + 5.0f);
         }
     }*/
+    m_ui_manager.update(dt);
 }
 
 void WorldScene::render(Renderer& renderer) {
-    Logger::info("World Scene Render Start !");
+
     renderer.render_world(m_client_world);
-    Logger::info("Client World Render Finish");
+
     renderer.render_dev_panel(m_dev_panel);
-    Logger::info("DevPanel Render Finish!");
+
+    m_ui_manager.render(renderer);
 }
 bool WorldScene::handle_event(const Event& e) {
+    if (m_ui_manager.handle_event(e)) {
+        return true;
+    }
     if (m_camera.handle_event(e)) {
         return true;
     }
@@ -65,6 +71,7 @@ void WorldScene::on_enter() {
     m_camera.camera_init(&m_client_world.get_player());
     m_scene_manager.app().window().set_camera(&m_camera);
     m_dev_panel.init();
+    m_ui_manager.init();
 }
 void WorldScene::on_leave() {
     m_client_world.request_exit();

src/texture_manager.cpp

@@ -307,16 +307,20 @@ int TextureManager::max_aniso() const { return static_cast<int>(m_max_aniso); }
 
 bool TextureManager::handle_event(const Event& e) {
     return std::visit(
-        Overloaded{[](const MouseMoveEvent& e) { return false; },
+        Overloaded{[](const MouseMoveEvent&) { return false; },
-                   [](const MouseButtonEvent& e) { return false; },
+                   [](const MouseButtonEvent&) { return false; },
-                   [](const MouseWheelEvent& e) { return false; },
+                   [](const MouseWheelEvent&) { return false; },
                    [this](const KeyEvent& e) {
                        if (handle_key_event(e)) {
                            return true;
                        }
                        return false;
                    },
-                   [](const TextInputEvent& e) { return false; }},
+                   [](const TextInputEvent&) { return false; },
+                   [](const WindowResizeEvent&) { return false; },
+                   [](const FrameBufferResizeEvent&) { return false; }
+
+        },
         e);
 }
 

src/tools/font.cpp

@@ -59,7 +59,7 @@ void Font::setup_font_character() {
         load_character(c);
     }
     m_text_texture->set_linear();
-    m_text_texture->set_clamp_to_edge(false, true, true);
+    m_text_texture->set_repeat(false, true, true);
 }
 
 std::vector<Vertex2D> Font::vertices(const std::string& text) {

src/ui/ui_vertex_data.cpp

@@ -28,7 +28,7 @@ void UIVertexData::upload() {
     m_vbo->buffer_data(m_vertices.data(), m_vertices.size() * sizeof(Vertex2D),
                        BufferUsage::DYNAMIC_DRAW);
 
-    m_vao->attribute(0, 3, GL_FLOAT, sizeof(Vertex2D), (void*)0);
+    m_vao->attribute(0, 2, GL_FLOAT, sizeof(Vertex2D), (void*)0);
     m_vao->attribute(1, 2, GL_FLOAT, sizeof(Vertex2D),
                      (void*)offsetof(Vertex2D, s));
     m_vao->attribute(2, 1, GL_FLOAT, sizeof(Vertex2D),

src/ui/world_ui_manager.cpp

@@ -0,0 +1,88 @@
+#include "Cubed/ui/world_ui_manager.hpp"
+
+#include "Cubed/app.hpp"
+#include "Cubed/debug_collector.hpp"
+#include "Cubed/render/renderer.hpp"
+#include "Cubed/scene/scene_manager.hpp"
+#include "Cubed/scene/world_scene.hpp"
+namespace Cubed {
+
+WorldUIManager::WorldUIManager(WorldScene& scene) : m_scene(scene) {}
+WorldUIManager::~WorldUIManager() {}
+
+void WorldUIManager::init() {
+    auto crosshair = std::make_unique<Image>();
+
+    crosshair->set_image("texture/ui/0.png",
+                         m_scene.scene_manager().app().texture_manager());
+    auto& renderer = m_scene.scene_manager().app().renderer();
+    crosshair
+        ->set_position(renderer.window_width() / 2 + crosshair->width() / 2,
+                       renderer.window_height() / 2 + crosshair->height() / 2)
+        .set_scale(3.0f);
+    m_widgets.try_emplace("crosshair", std::move(crosshair));
+}
+void WorldUIManager::update(float) {}
+void WorldUIManager::render(Renderer& renderer) {
+    renderer.begin_render_ui();
+
+    auto& widget = DebugCollector::get().get_widget();
+    widget.render(renderer);
+    for (auto& widget : m_widgets) {
+        widget.second->render(renderer);
+    }
+
+    renderer.end_render_ui();
+}
+bool WorldUIManager::handle_event(const Event& e) {
+    return std::visit(
+        Overloaded{[](const MouseMoveEvent&) { 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_button_event(const MouseButtonEvent&) {
+    return false;
+}
+bool WorldUIManager::handle_window_resize_event(const WindowResizeEvent& e) {
+    auto it = m_widgets.find("crosshair");
+    if (it != m_widgets.end()) {
+        auto* crosshair = dynamic_cast<Image*>(it->second.get());
+        if (crosshair) {
+            crosshair->set_position(e.width / 2 + crosshair->width() / 2,
+                                    e.height / 2 + crosshair->height() / 2);
+        }
+    }
+    return false;
+}
+bool WorldUIManager::handle_mouse_wheel_event(const MouseWheelEvent&) {
+    return false;
+}
+bool WorldUIManager::handle_key_event(const KeyEvent&) { return false; }
+
+} // namespace Cubed

src/window.cpp

@@ -1,7 +1,6 @@
 #include "Cubed/window.hpp"
 
 #include "Cubed/camera.hpp"
-#include "Cubed/render/renderer.hpp"
 #include "Cubed/tools/cubed_assert.hpp"
 #include "Cubed/tools/font.hpp"
 #include "Cubed/tools/log.hpp"
@@ -15,8 +14,7 @@ namespace Cubed {
 static int windowed_xpos = 0, windowed_ypos = 0;
 static int windowed_width = 800, windowed_height = 600;
 
-Window::Window(Renderer& renderer, Config& config)
+Window::Window(Config& config) : m_config(config) {}
-    : m_renderer(renderer), m_config(config) {}
 
 Window::~Window() {
     if (m_imgui_init) {
@@ -42,32 +40,30 @@ const GLFWwindow* Window::get_glfw_window() const { return m_window; }
 
 GLFWwindow* Window::get_glfw_window() { return m_window; }
 
-void Window::update_viewport() {
-    glfwGetFramebufferSize(m_window, &m_width, &m_height);
-    m_aspect = (float)m_width / (float)m_height;
-    glViewport(0, 0, m_width, m_height);
-    m_renderer.update_proj_matrix(m_aspect, m_width, m_height);
-    m_renderer.updata_framebuffer(m_width, m_height);
-    m_config.set("window.width", windowed_width);
-    m_config.set("window.height", windowed_height);
-}
-
 bool Window::handle_event(const Event& e) {
-    return std::visit(Overloaded{[](const MouseMoveEvent& e) { return false; },
+    return std::visit(
+        Overloaded{[](const MouseMoveEvent&) { return false; },
                    [this](const MouseButtonEvent& e) {
                        if (handle_mouse_button_event(e)) {
                            return true;
                        }
                        return false;
                    },
-                                 [](const MouseWheelEvent& e) { return false; },
+                   [](const MouseWheelEvent&) { return false; },
                    [this](const KeyEvent& e) {
                        if (handle_key_event(e)) {
                            return true;
                        }
                        return false;
                    },
-                                 [](const TextInputEvent& e) { return false; }},
+                   [](const TextInputEvent&) { return false; },
+                   [this](const WindowResizeEvent& e) {
+                       handle_window_resize_event(e);
+                       return false;
+                   },
+                   [](const FrameBufferResizeEvent&) { return false; }
+
+        },
         e);
 }
 
@@ -88,6 +84,12 @@ bool Window::handle_key_event(const KeyEvent& e) {
     return false;
 }
 
+bool Window::handle_window_resize_event(const WindowResizeEvent& e) {
+    m_window_height = e.height;
+    m_window_width = e.width;
+    return false;
+}
+
 bool Window::handle_mouse_button_event(const MouseButtonEvent& e) {
     if (e.key == MouseKey::LEFT_BUTTON && e.action == KeyAction::PRESS) {
         if (is_mouse_enable()) {
@@ -107,15 +109,18 @@ void Window::init() {
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
     glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
-    m_width = m_config.get("window.width", 800);
+
-    m_height = m_config.get("window.height", 600);
+    m_window_width = m_config.get("window.width", 800);
+    m_window_height = m_config.get("window.height", 600);
+
     if (m_config.get("window.fullscreen", false)) {
         GLFWmonitor* primary_monitor = glfwGetPrimaryMonitor();
         const GLFWvidmode* mode = glfwGetVideoMode(primary_monitor);
         m_window = glfwCreateWindow(mode->width, mode->height, "Cubed",
                                     primary_monitor, NULL);
     } else {
-        m_window = glfwCreateWindow(m_width, m_height, "Cubed", NULL, NULL);
+        m_window = glfwCreateWindow(m_window_width, m_window_height, "Cubed",
+                                    NULL, NULL);
     }
 
     glfwMakeContextCurrent(m_window);
@@ -168,12 +173,13 @@ void Window::hot_reload() {
             Logger::error("Can't Find Monitor");
         }
     }
-    update_viewport();
     if (!m_mouse_enable) {
         glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
     } else {
         glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
     }
+    m_config.set("window.width", windowed_width);
+    m_config.set("window.height", windowed_height);
 }
 
 void Window::toggle_fullscreen() {
@@ -195,7 +201,8 @@ void Window::toggle_fullscreen() {
                              GL_DONT_CARE);
         m_config.set("window.fullscreen", true);
     }
-    update_viewport();
+    m_config.set("window.width", windowed_width);
+    m_config.set("window.height", windowed_height);
 }
 
 void Window::toggle_mouse_able() {