From a76180aaf4e38a1623a93586800e0f3e54d58c1b Mon Sep 17 00:00:00 2001 From: hachem Date: Sun, 23 Aug 2026 17:21:37 +0200 Subject: feat: complete RHI api --- src/core/application.cpp | 403 ++++++++++++++++++++++++++---------------- src/core/application.h | 53 ++++-- src/core/settings_manager.cpp | 1 - src/core/window.cpp | 98 +--------- src/core/window.h | 12 -- 5 files changed, 290 insertions(+), 277 deletions(-) (limited to 'src') diff --git a/src/core/application.cpp b/src/core/application.cpp index 4e47b86..215ce9c 100644 --- a/src/core/application.cpp +++ b/src/core/application.cpp @@ -1,29 +1,32 @@ #include "application.h" -#include "rendering/renderer.h" +#include "rendering/render_api.h" #include "settings_manager.h" #include "hdri_manager.h" -#include "states/simulation_state.h" -#include "states/config_state.h" -#include "states/world_builder_state.h" +#include "platform/opengl/opengl_device.h" +#include "platform/vulkan/vulkan_device.h" #include #include -#include -#include "platform/vulkan/vulkan_renderer.h" -#include "platform/opengl/opengl_renderer.h" - -#ifdef __APPLE__ -#include "platform/metal/metal_context.h" -#include "platform/vulkan/vulkan_context.h" -#endif +#include +#include +#include +#include namespace Donut { Application* Application::s_instance = nullptr; + static double g_scroll_accum = 0.0; + static GLFWscrollfun g_prev_scroll = nullptr; + static void donut_scroll_callback(GLFWwindow* w, double x, double y) + { + if (g_prev_scroll) g_prev_scroll(w, x, y); + g_scroll_accum += y; + } + Application::Application(const std::string& name, int width, int height) : m_running(true), m_minimized(false) { @@ -38,13 +41,10 @@ namespace Donut } if (RendererAPI::get_api() == RendererAPI::API::Vulkan) - vulkan_prepare_glfw(); + RHI::vulkan_prepare_glfw(); m_window = create_scope(name, width, height); - m_window->set_event_callback([this](Event& event) - { - on_event(event); - }); + m_window->set_event_callback([this](Event& event) { on_event(event); }); on_init(); } @@ -55,29 +55,222 @@ namespace Donut s_instance = nullptr; } + auto Application::on_init() -> void + { + int w = 0, h = 0; + glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h); + + if (RendererAPI::get_api() == RendererAPI::API::Vulkan) + m_device = RHI::create_vulkan_device(); + else + m_device = RHI::create_opengl_device(); + + if (!m_device->init(m_window->get_native_window(), w, h)) + { + DONUT_ERROR("RHI device initialization failed"); + return; + } + + m_hdri_path = "assets/hdri/hdr_blue_nebulae_1.hdr"; + m_cubemap = m_device->create_cubemap_from_hdri(m_hdri_path); + + m_scene_renderer = create_scope(); + m_scene_renderer->init(*m_device); + m_black_hole_renderer = create_scope(); + m_black_hole_renderer->init(*m_device); + + m_camera.set_camera_mode(CameraMode::Orbital); + m_camera.set_orbital_target(glm::vec3(0.0f)); + m_camera.set_orbital_radius(4e11); + m_camera.set_orbital_limits(2.2e11, 1.5e12); + m_camera.set_orbital_speed(0.01f); + m_camera.set_zoom_speed(3e10); + m_camera.set_azimuth(0.0f); + m_camera.set_elevation(1.25f); + + m_scene_camera.set_camera_mode(CameraMode::Orbital); + m_scene_camera.set_orbital_target(glm::vec3(0.0f)); + m_scene_camera.set_orbital_radius(15.0); + m_scene_camera.set_orbital_limits(2.0, 200.0); + m_scene_camera.set_orbital_speed(0.01f); + m_scene_camera.set_zoom_speed(2.0); + m_scene_camera.set_azimuth(0.0f); + m_scene_camera.set_elevation((float)std::numbers::pi / 3.0f); + m_scene_camera.update_orbital(); + + m_device->init_imgui(); + ImGuiIO& io = ImGui::GetIO(); + if (!io.Fonts->AddFontFromFileTTF("assets/fonts/inter/static/Inter_18pt-Regular.ttf", 16.0f)) + io.Fonts->AddFontDefault(); + + g_prev_scroll = glfwSetScrollCallback((GLFWwindow*)m_window->get_native_window(), donut_scroll_callback); + + m_start_time = glfwGetTime(); + DONUT_INFO("Application ready on {} backend", m_device->device_name()); + } + auto Application::run() -> void { while (m_running) { - if (m_renderer) + glfwPollEvents(); + if (!m_minimized && m_device) + render_frame(); + } + } + + auto Application::render_frame() -> void + { + RHI::CommandList* cmd = m_device->begin_frame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f)); + if (!cmd) return; + + m_device->imgui_new_frame(); + build_ui(); + process_input(); + + const glm::vec4 clear(0.05f, 0.06f, 0.10f, 1.0f); + int w = 0, h = 0; + glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h); + + if (m_scene_mode) + { + float aspect = (float)w / (float)std::max(h, 1); + m_scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f); + CameraView cv; + cv.view = m_scene_camera.get_view_matrix(); + cv.projection = m_scene_camera.get_projection_matrix(); + cv.position = m_scene_camera.get_orbital_position(); + cv.fb_width = w; cv.fb_height = h; + + cmd->begin_render_pass(nullptr, clear); + m_scene_renderer->render(*cmd, cv, m_scene_objects, m_selected_object, m_cubemap.get()); + m_device->imgui_render(*cmd); + cmd->end_render_pass(); + } + else + { + GeodesicView gv; + glm::vec3 pos, fwd; + if (m_camera.get_camera_mode() == CameraMode::FPS) { - glfwPollEvents(); - if (!m_minimized) - m_renderer->draw_frame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f), - [this] { build_ui(); }); + pos = m_camera.get_position(); + fwd = m_camera.get_forward_direction(); } else { - if (!m_minimized) - { - on_update(); - on_render(); - } - m_window->on_update(); + pos = m_camera.get_orbital_position(); + fwd = glm::normalize(m_camera.get_orbital_target() - pos); + } + glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0))); + gv.position = pos; gv.right = right; gv.up = glm::cross(right, fwd); gv.forward = fwd; + gv.tan_half_fov = (float)tan(glm::radians(m_bh_params.fov_degrees * 0.5f)); + gv.aspect = (float)BlackHoleRenderer::GEO_HI_W / (float)BlackHoleRenderer::GEO_HI_H; + gv.moving = m_user_moving; + gv.time = (float)(glfwGetTime() - m_start_time); + + m_black_hole_renderer->render_geodesic(*cmd, gv, m_bh_params, m_cubemap.get()); + cmd->begin_render_pass(nullptr, clear); + m_black_hole_renderer->blit(*cmd, w, h); + m_device->imgui_render(*cmd); + cmd->end_render_pass(); + } + + m_device->end_frame(); + } + + auto Application::process_input() -> void + { + GLFWwindow* window = (GLFWwindow*)m_window->get_native_window(); + bool over_ui = ImGui::GetCurrentContext() && ImGui::GetIO().WantCaptureMouse; + + double now = glfwGetTime(); + float dt = m_last_frame_time > 0.0 ? (float)(now - m_last_frame_time) : 0.0f; + m_last_frame_time = now; + + double mx = 0, my = 0; + glfwGetCursorPos(window, &mx, &my); + bool left_down = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS; + + if (!m_scene_mode && m_camera.get_camera_mode() == CameraMode::FPS) + { + if (left_down && !m_left_was_down) { m_fps_last_x = mx; m_fps_last_y = my; } + if (left_down && !over_ui) + m_camera.on_mouse_move(float(mx - m_fps_last_x), float(m_fps_last_y - my)); + m_fps_last_x = mx; m_fps_last_y = my; + m_left_was_down = left_down; + + bool over_kb = ImGui::GetCurrentContext() && ImGui::GetIO().WantCaptureKeyboard; + bool moved = false; + if (!over_kb && dt > 0.0f) + { + float mdt = dt * (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ? 4.0f : 1.0f); + if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { m_camera.move_forward(mdt); moved = true; } + if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { m_camera.move_backward(mdt); moved = true; } + if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { m_camera.move_left(mdt); moved = true; } + if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { m_camera.move_right(mdt); moved = true; } + if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) { m_camera.move_up(mdt); moved = true; } + if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) { m_camera.move_down(mdt); moved = true; } } + g_scroll_accum = 0.0; + m_user_moving = moved || (left_down && !over_ui); + } + else + { + Camera& cam = m_scene_mode ? m_scene_camera : m_camera; + if (left_down && !m_left_was_down && !over_ui) + cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0); + else if (!left_down && m_left_was_down) + cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE, 0); + m_left_was_down = left_down; + + cam.process_orbital_mouse_move(mx, my); + + double scroll = g_scroll_accum; g_scroll_accum = 0.0; + if (scroll != 0.0 && !over_ui) + cam.process_orbital_scroll(0.0, scroll); + + m_user_moving = cam.is_dragging() || cam.is_panning(); + } + } + + auto Application::set_free_fly(bool enabled) -> void + { + const bool is_fps = m_camera.get_camera_mode() == CameraMode::FPS; + if (enabled == is_fps) return; + if (enabled) + { + glm::vec3 pos = m_camera.get_orbital_position(); + glm::vec3 fwd = glm::normalize(m_camera.get_orbital_target() - pos); + float pitch = glm::degrees(asin(glm::clamp(fwd.y, -1.0f, 1.0f))); + float yaw = glm::degrees(atan2(fwd.z, fwd.x)); + m_camera.set_camera_mode(CameraMode::FPS); + m_camera.set_movement_speed(2.0e10f); + m_camera.set_mouse_sensitivity(0.15f); + m_camera.set_position(pos); + m_camera.set_rotation(glm::vec3(pitch, yaw, 0.0f)); + } + else + { + m_camera.set_camera_mode(CameraMode::Orbital); } } + auto Application::reset_camera() -> void + { + m_camera.set_camera_mode(CameraMode::Orbital); + m_camera.set_orbital_radius(4e11); + m_camera.set_azimuth(0.0f); + m_camera.set_elevation(1.25f); + } + + auto Application::set_hdri(const std::string& path) -> void + { + if (m_hdri_path == path || !m_device) return; + m_device->wait_idle(); + m_cubemap = m_device->create_cubemap_from_hdri(path); + m_hdri_path = path; + } + static auto apply_donut_style() -> void { ImGuiStyle& s = ImGui::GetStyle(); @@ -117,8 +310,7 @@ namespace Donut { static bool styled = false; if (!styled) { apply_donut_style(); styled = true; } - if (!m_renderer) return; - RendererBackend& r = *m_renderer; + if (!m_device) return; ImGui::DockSpaceOverViewport(0, ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode); @@ -126,7 +318,7 @@ namespace Donut ImGui::Begin("Donut \xc2\xb7 Black Hole"); ImGuiIO& io = ImGui::GetIO(); - ImGui::TextDisabled("%s", r.device_name().empty() ? "GPU" : r.device_name().c_str()); + ImGui::TextDisabled("%s", m_device->device_name().empty() ? "GPU" : m_device->device_name().c_str()); ImGui::Text("%.0f FPS", io.Framerate); ImGui::SameLine(); ImGui::TextDisabled("%.1f ms/frame", io.Framerate > 0 ? 1000.0f / io.Framerate : 0.0f); ImGui::Spacing(); @@ -149,29 +341,28 @@ namespace Donut } ImGui::Spacing(); - bool scene = r.is_scene_mode(); ImGui::TextDisabled("VIEW"); - if (ImGui::RadioButton("Black hole", !scene)) r.set_scene_mode(false); + if (ImGui::RadioButton("Black hole", !m_scene_mode)) m_scene_mode = false; ImGui::SameLine(); - if (ImGui::RadioButton("Scene", scene)) r.set_scene_mode(true); + if (ImGui::RadioButton("Scene", m_scene_mode)) m_scene_mode = true; ImGui::Separator(); - if (scene) + if (m_scene_mode) { build_scene_ui(); } else { - BlackHoleParams& bh = r.black_hole_params(); + BlackHoleParams& bh = m_bh_params; if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen)) { - bool ff = r.is_free_fly(); - if (ImGui::RadioButton("Orbital", !ff)) r.set_free_fly(false); + bool ff = m_camera.get_camera_mode() == CameraMode::FPS; + if (ImGui::RadioButton("Orbital", !ff)) set_free_fly(false); ImGui::SameLine(); - if (ImGui::RadioButton("Free-fly", ff)) r.set_free_fly(true); + if (ImGui::RadioButton("Free-fly", ff)) set_free_fly(true); ImGui::SameLine(); - if (ImGui::Button("Reset view")) r.reset_camera(); + if (ImGui::Button("Reset view")) reset_camera(); ImGui::SliderFloat("FOV", &bh.fov_degrees, 20.0f, 90.0f, "%.0f\xc2\xb0"); ImGui::TextDisabled(ff ? "WASD move | Q/E down-up | Shift boost | drag look" : "Drag to orbit | scroll to zoom"); @@ -197,15 +388,14 @@ namespace Donut if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen)) { auto& hdri = HDRIManager::get(); - std::string current = r.current_hdri(); - std::string preview = hdri.get_hdri_name(current); + std::string preview = hdri.get_hdri_name(m_hdri_path); if (ImGui::BeginCombo("Starfield", preview.c_str())) { for (const auto& path : hdri.get_available_hdri()) { - bool selected = (path == current); + bool selected = (path == m_hdri_path); if (ImGui::Selectable(hdri.get_hdri_name(path).c_str(), selected)) - r.set_hdri(path); + set_hdri(path); if (selected) ImGui::SetItemDefaultFocus(); } ImGui::EndCombo(); @@ -219,14 +409,12 @@ namespace Donut auto Application::build_scene_ui() -> void { - RendererBackend& r = *m_renderer; if (!ImGui::CollapsingHeader("Objects", ImGuiTreeNodeFlags_DefaultOpen)) return; ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind."); - auto& objs = r.scene_objects(); - static int sel = 0; - if (sel >= (int)objs.size()) sel = (int)objs.size() - 1; + auto& objs = m_scene_objects; + if (m_selected_object >= (int)objs.size()) m_selected_object = (int)objs.size() - 1; ImGui::Text("Spheres (%d)", (int)objs.size()); if (ImGui::Button("Add") && objs.size() < 64) @@ -236,27 +424,26 @@ namespace Donut o.radius = 1.5f; o.color = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4)); objs.push_back(o); - sel = (int)objs.size() - 1; + m_selected_object = (int)objs.size() - 1; } ImGui::SameLine(); if (ImGui::Button("Delete") && !objs.empty()) { - objs.erase(objs.begin() + sel); - if (sel >= (int)objs.size()) sel = (int)objs.size() - 1; + objs.erase(objs.begin() + m_selected_object); + if (m_selected_object >= (int)objs.size()) m_selected_object = (int)objs.size() - 1; } ImGui::BeginChild("obj_list", ImVec2(0, 90), true); for (int i = 0; i < (int)objs.size(); ++i) { std::string label = "Sphere " + std::to_string(i); - if (ImGui::Selectable(label.c_str(), sel == i)) sel = i; + if (ImGui::Selectable(label.c_str(), m_selected_object == i)) m_selected_object = i; } ImGui::EndChild(); - r.set_selected_object(sel); - if (sel >= 0 && sel < (int)objs.size()) + if (m_selected_object >= 0 && m_selected_object < (int)objs.size()) { - SceneObject& o = objs[sel]; + SceneObject& o = objs[m_selected_object]; ImGui::DragFloat3("Position", &o.position.x, 0.1f); ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f); ImGui::ColorEdit3("Color", &o.color.x); @@ -280,112 +467,26 @@ namespace Donut dispatcher.dispatch([this, &event](WindowResizeEvent& e) { - if (e.get_width() == 0 || e.get_height() == 0) - m_minimized = true; - else - m_minimized = false; - - if (m_renderer) - { - m_renderer->resize(e.get_width(), e.get_height()); - } - else - { - Renderer::on_window_resize(e.get_width(), e.get_height()); - if (m_engine) m_engine->set_window_dimensions(e.get_width(), e.get_height()); - } + m_minimized = (e.get_width() == 0 || e.get_height() == 0); + if (m_device) m_device->resize(e.get_width(), e.get_height()); event.handled = true; return true; }); - - dispatcher.dispatch([this, &event](KeyPressedEvent& e) - { - if (!m_state_manager) - return true; - if (e.get_key_code() == GLFW_KEY_1) - { - m_state_manager->switch_to_state("Config"); - event.handled = true; - return true; - } - else if (e.get_key_code() == GLFW_KEY_2) - { - m_state_manager->switch_to_state("Simulation"); - event.handled = true; - return true; - } - else if (e.get_key_code() == GLFW_KEY_3) - { - m_state_manager->switch_to_state("WorldBuilder"); - event.handled = true; - return true; - } - - return true; - }); - - if (m_state_manager) - m_state_manager->on_event(event); - } - - auto Application::on_init() -> void - { - int w = 0, h = 0; - glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h); - - if (RendererAPI::get_api() == RendererAPI::API::Vulkan) - m_renderer = create_scope(); - else - m_renderer = create_scope(); - - if (!m_renderer->init(m_window->get_native_window(), w, h)) - DONUT_ERROR("Renderer initialization failed"); - else - m_renderer->init_ui(); } auto Application::on_shutdown() -> void { - if (m_renderer) - { - m_renderer->shutdown(); - m_renderer.reset(); - } - else + if (m_device) { - if (m_state_manager) - m_state_manager->shutdown(); - Renderer::shutdown(); + m_device->wait_idle(); + m_scene_renderer.reset(); + m_black_hole_renderer.reset(); + m_cubemap.reset(); + HDRIManager::get().clear_cache(); + m_device->shutdown(); + m_device.reset(); } SettingsManager::shutdown(); Logger::shutdown(); } - - auto Application::on_update() -> void - { - float current_frame = (float)glfwGetTime(); - m_delta_time = current_frame - m_last_frame; - m_last_frame = current_frame; - - m_state_manager->update(m_delta_time); - } - - auto Application::on_render() -> void - { - m_state_manager->render(); - m_window->begin_im_gui_frame(); - - ImGuizmo::BeginFrame(); - ImGuizmo::SetOrthographic(false); - - setup_docking_layout(); - m_state_manager->on_im_ui_render(); - m_window->end_im_gui_frame(); - } - - auto Application::setup_docking_layout() -> void - { - ImGuiViewport* viewport = ImGui::GetMainViewport(); - ImGui::DockSpaceOverViewport(0, viewport, ImGuiDockNodeFlags_PassthruCentralNode); - } }; diff --git a/src/core/application.h b/src/core/application.h index f2b5656..84cc600 100644 --- a/src/core/application.h +++ b/src/core/application.h @@ -1,13 +1,17 @@ #pragma once -#include "state_manager.h" #include "memory.h" #include "window.h" #include "event.h" #include "log.h" +#include "camera.h" -#include "engine/engine.h" -#include "rendering/renderer_backend.h" +#include "rendering/rhi.h" +#include "rendering/scene_renderer.h" +#include "rendering/black_hole_renderer.h" + +#include +#include namespace Donut { @@ -21,33 +25,50 @@ namespace Donut auto run() -> void; auto close() -> void; - auto get_window() -> Window& { return *m_window; } - auto get_state_manager() -> StateManager& { return *m_state_manager; } - auto get_engine() -> Engine& { return *m_engine; } - static auto get() -> Application& { return *s_instance; } + auto get_window() -> Window& { return *m_window; } + static auto get() -> Application& { return *s_instance; } private: auto on_init() -> void; auto on_shutdown() -> void; - auto on_update() -> void; - auto on_render() -> void; auto on_event(Event& event) -> void; - auto setup_docking_layout() -> void; + auto build_ui() -> void; auto build_scene_ui() -> void; + auto process_input() -> void; + auto set_free_fly(bool enabled) -> void; + auto reset_camera() -> void; + auto set_hdri(const std::string& path) -> void; + + auto render_frame() -> void; + private: - Scope m_state_manager; Scope m_window; - Scope m_engine; - Scope m_renderer; + + Scope m_device; + Scope m_scene_renderer; + Scope m_black_hole_renderer; + Ref m_cubemap; + + Camera m_camera{ 60.0f, 16.0f / 9.0f, 0.1f, 100.0f }; + Camera m_scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f }; + + BlackHoleParams m_bh_params; + std::vector m_scene_objects{ SceneObject{} }; + int m_selected_object = 0; + bool m_scene_mode = false; + std::string m_hdri_path; + + bool m_left_was_down = false; + double m_fps_last_x = 0.0, m_fps_last_y = 0.0; + double m_last_frame_time = 0.0; + double m_start_time = 0.0; + bool m_user_moving = false; bool m_running; bool m_minimized; - float m_delta_time = 0.0f; - float m_last_frame = 0.0f; - static Application* s_instance; }; } diff --git a/src/core/settings_manager.cpp b/src/core/settings_manager.cpp index ca4cac5..6909c60 100644 --- a/src/core/settings_manager.cpp +++ b/src/core/settings_manager.cpp @@ -1,7 +1,6 @@ #include "settings_manager.h" #include "log.h" #include "theme_manager.h" -#include "rendering/renderer.h" #include #include diff --git a/src/core/window.cpp b/src/core/window.cpp index 619d7e1..12fb46e 100644 --- a/src/core/window.cpp +++ b/src/core/window.cpp @@ -1,14 +1,8 @@ -#include #include "window.h" -#include "theme_manager.h" -#include "rendering/renderer.h" +#include "rendering/render_api.h" #include -#include -#include -#include - namespace Donut { static bool s_glfw_initialized = false; @@ -89,8 +83,6 @@ namespace Donut { DONUT_INFO("Shutting down window: ", m_title); - shutdown_im_gui(); - glfwDestroyWindow(m_window); s_glfw_window_count--; @@ -128,94 +120,6 @@ namespace Donut GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN); } - auto Window::init_im_gui() -> void - { - IMGUI_CHECKVERSION(); - ImGui::CreateContext(); - ImGuiIO& io = ImGui::GetIO(); - io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; - io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; -#ifndef __APPLE__ - io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; -#endif - - setup_im_gui_fonts(); - ThemeManager::set_theme(Theme::Dark); - - ImGuiStyle& style = ImGui::GetStyle(); - if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) - { - style.WindowRounding = 0.0f; - style.Colors[ImGuiCol_WindowBg].w = 1.0f; - } - - ImGui_ImplGlfw_InitForOpenGL(m_window, true); -#ifdef __APPLE__ - ImGui_ImplOpenGL3_Init("#version 150"); -#else - ImGui_ImplOpenGL3_Init("#version 130"); -#endif - - DONUT_INFO("ImGUI initialized successfully"); - } - - auto Window::setup_im_gui_fonts() -> void - { - ImGuiIO& io = ImGui::GetIO(); - io.Fonts->Clear(); - - m_main_font = io.Fonts->AddFontFromFileTTF("assets/fonts/inter/static/Inter_18pt-Regular.ttf", 16.0f); - if (!m_main_font) - { - DONUT_WARN("Failed to load Inter font, falling back to default"); - m_main_font = io.Fonts->AddFontDefault(); - } - else - DONUT_INFO("Successfully loaded Inter font"); - - m_large_font = io.Fonts->AddFontFromFileTTF("assets/fonts/inter/static/Inter_18pt-Bold.ttf", 20.0f); - if (!m_large_font) - m_large_font = m_main_font; - - m_small_font = io.Fonts->AddFontFromFileTTF("assets/fonts/inter/static/Inter_18pt-Light.ttf", 12.0f); - if (!m_small_font) - m_small_font = m_main_font; - - io.FontDefault = m_main_font; - DONUT_INFO("ImGUI fonts loaded successfully"); - } - - auto Window::shutdown_im_gui() -> void - { - ImGui_ImplOpenGL3_Shutdown(); - ImGui_ImplGlfw_Shutdown(); - ImGui::DestroyContext(); - - DONUT_INFO("ImGUI shutdown"); - } - - auto Window::begin_im_gui_frame() -> void - { - ImGui_ImplOpenGL3_NewFrame(); - ImGui_ImplGlfw_NewFrame(); - ImGui::NewFrame(); - } - - auto Window::end_im_gui_frame() -> void - { - ImGui::Render(); - ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); - - ImGuiIO& io = ImGui::GetIO(); - if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) - { - GLFWwindow* backup_current_context = glfwGetCurrentContext(); - ImGui::UpdatePlatformWindows(); - ImGui::RenderPlatformWindowsDefault(); - glfwMakeContextCurrent(backup_current_context); - } - } - auto Window::glfw_error_callback(int error, const char* description) -> void { DONUT_ERROR("GLFW Error ({}): {}", error, description ? description : ""); diff --git a/src/core/window.h b/src/core/window.h index 9b7d7b9..b8b59c5 100644 --- a/src/core/window.h +++ b/src/core/window.h @@ -4,7 +4,6 @@ #include "log.h" #include -#include #include @@ -38,17 +37,10 @@ namespace Donut auto is_cursor_locked() const -> bool { return m_cursor_locked; } auto is_cursor_visible() const -> bool { return m_cursor_visible; } - auto init_im_gui() -> void; - auto begin_im_gui_frame() -> void; - auto end_im_gui_frame() -> void; - private: auto init() -> void; auto shutdown() -> void; - auto setup_im_gui_fonts() -> void; - auto shutdown_im_gui() -> void; - static auto glfw_error_callback(int error, const char* description) -> void; static auto glfw_window_close_callback(GLFWwindow* window) -> void; static auto glfw_window_size_callback(GLFWwindow* window, int width, int height) -> void; @@ -70,9 +62,5 @@ namespace Donut bool m_is_closed; bool m_cursor_locked = false; bool m_cursor_visible = true; - - ImFont* m_main_font = nullptr; - ImFont* m_small_font = nullptr; - ImFont* m_large_font = nullptr; }; } -- cgit v1.3