zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-08-09 02:07:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
zhenyan121
2026-07-14 09:15:54 +08:00
parent 80ba6dad89
commit 558fd6311d
7 changed files with 148 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/Cubed/ui/main_menu_ui_manager.hpp
View File

@@ -1,14 +1,11 @@
#pragma once
#include "Cubed/input/event.hpp"
#include "Cubed/ui/widget.hpp"
#include "Cubed/ui/ui_manager.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 render(Renderer& renderer);
void update(float dt);
bool handle_event(const Event& e);
void init() override;
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

33
include/Cubed/ui/ui_manager.hpp Normal file
View File

@@ -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

18
include/Cubed/ui/world_ui_manager.hpp
View File

@@ -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 update(float dt);
void render(Renderer& renderer);
bool handle_event(const Event& e);
void init() override;
void render(Renderer& renderer) override;
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

1
src/CMakeLists.txt
View File

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

84
src/ui/main_menu_ui_manager.cpp
View File

@@ -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

104
src/ui/ui_manager.cpp Normal file
View File

@@ -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

91
src/ui/world_ui_manager.cpp
View File

@@ -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));
}
void WorldUIManager::update(float dt) {
for (auto& w : m_widgets) {
w.second->update(dt);
}
m_widgets.try_emplace("crosshair", crosshair.get());
m_root_widget = std::move(crosshair);
}
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);
}
m_root_widget->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