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

refactor: add framebuffer resize event and separate UI management

Browse Source
This commit is contained in:
zhenyan121
2026-07-12 18:38:42 +08:00
parent 5712ba0600
commit cb1eb25e7b
20 changed files with 331 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Cubed/app.hpp
View File

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

13
include/Cubed/input/event.hpp
View File

@@ -41,8 +41,17 @@ struct TextInputEvent {
TextInputEvent(std::string t) : text(std::move(t)) {}
};
using Event = std::variant<MouseMoveEvent, MouseButtonEvent, MouseWheelEvent,
KeyEvent, TextInputEvent>;
struct WindowResizeEvent {
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()...;

32
include/Cubed/render/renderer.hpp
View File

@@ -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 width() const;
float window_height() 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_height = 0.0f;
float m_frame_width = 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

3
include/Cubed/scene/world_scene.hpp
View File

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

13
include/Cubed/ui/ui_manager.hpp
View File

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

34
include/Cubed/ui/world_ui_manager.hpp Normal file
View File

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

11
include/Cubed/window.hpp
View File

@@ -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_height;
Renderer& m_renderer;
int m_window_width;
int m_window_height;
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);
};

1
src/CMakeLists.txt
View File

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

49
src/app.cpp
View File

@@ -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_window(m_renderer, m_game_config), m_scene_manager(*this) {}
m_renderer(m_texture_manager, m_game_config), m_window(m_game_config),
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;
}

11
src/camera.cpp
View File

@@ -124,15 +124,20 @@ bool Camera::handle_event(const Event& e) {
return false;
},
[](const MouseButtonEvent& e) { return false; },
[](const MouseWheelEvent& e) { return false; },
[](const MouseButtonEvent&) { 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);
}

6
src/gameplay/client_world.cpp
View File

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

83
src/render/renderer.cpp
View File

@@ -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::width() const { return m_width; }
float Renderer::window_height() const { return m_window_height; }
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

8
src/render/world_renderer.cpp
View File

@@ -215,8 +215,8 @@ void WorldRenderer::render_world(ClientWorld& world) {
// shader map
auto m_height = m_renderer.height();
auto m_width = m_renderer.width();
auto height = m_renderer.frame_height();
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);

3
src/scene/scene_manager.cpp
View File

@@ -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);
}

15
src/scene/world_scene.cpp
View File

@@ -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();

12
src/texture_manager.cpp
View File

@@ -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; },
[](const MouseButtonEvent& e) { return false; },
[](const MouseWheelEvent& e) { return false; },
Overloaded{[](const MouseMoveEvent&) { return false; },
[](const MouseButtonEvent&) { 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);
}

2
src/tools/font.cpp
View File

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

2
src/ui/ui_vertex_data.cpp
View File

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

88
src/ui/world_ui_manager.cpp Normal file
View File

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

49
src/window.cpp
View File

@@ -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)
: m_renderer(renderer), m_config(config) {}
Window::Window(Config& config) : 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() {