aboutsummaryrefslogtreecommitdiff
path: root/src/core/application.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/application.cpp')
-rw-r--r--src/core/application.cpp422
1 files changed, 265 insertions, 157 deletions
diff --git a/src/core/application.cpp b/src/core/application.cpp
index ae8a5d9..6239c36 100644
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -1,36 +1,41 @@
#include "application.h"
-#include "rendering/renderer.h"
+#include "rendering/render_api.h" // RendererAPI
#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 <GLFW/glfw3.h>
#include <imgui.h>
-#include <ImGuizmo.h>
-#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 <glm/gtc/matrix_transform.hpp>
+#include <algorithm>
+#include <cmath>
+#include <numbers>
namespace Donut
{
Application* Application::s_instance = nullptr;
+ // Scroll is delivered through a GLFW callback; accumulate it here and drain it
+ // once per frame in process_input (chaining ImGui's own scroll handler).
+ 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)
{
s_instance = this;
- // Select the render API before the window is created: the window is
- // built differently for Vulkan (GLFW_NO_API) than for OpenGL.
+ // Select the render API before the window is created: the window is built
+ // differently for Vulkan (GLFW_NO_API) than for OpenGL.
Logger::init();
SettingsManager::initialize();
{
@@ -40,13 +45,10 @@ namespace Donut
}
if (RendererAPI::get_api() == RendererAPI::API::Vulkan)
- vulkan_prepare_glfw(); // must precede glfwInit() inside the Window ctor
+ RHI::vulkan_prepare_glfw(); // must precede glfwInit() inside the Window ctor
m_window = create_scope<Window>(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();
}
@@ -57,27 +59,225 @@ 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<SceneRenderer>();
+ m_scene_renderer->init(*m_device);
+ m_black_hole_renderer = create_scope<BlackHoleRenderer>();
+ m_black_hole_renderer->init(*m_device);
+
+ // Black-hole camera: large-scale orbital viewer outside the disk.
+ m_camera.set_camera_mode(CameraMode::Orbital);
+ m_camera.set_orbital_target(glm::vec3(0.0f));
+ m_camera.set_orbital_radius(4e11); // ~31 r_s: outside the 12 r_s disk
+ 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);
+
+ // Scene camera: normal-scale orbital world-builder viewer.
+ 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();
+ // Load the UI font into the device-created ImGui context (backend-agnostic;
+ // the backend rebuilds the atlas on the next frame).
+ 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; // frame skipped (e.g. swapchain recreation)
+
+ 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(); // before the ImGui frame so input is current
- 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(); // polls events + swaps buffers (OpenGL)
+ 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)
+ {
+ // Seed the fly pose from the current orbital framing so the view is continuous.
+ 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); // orbital state was left intact
+ }
+ }
+
+ 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); // old cube freed after idle
+ m_hdri_path = path;
}
// One-time ImGui theme: rounded, roomy, dark with a warm accretion-disk accent.
@@ -120,8 +320,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;
// Full-viewport dock space with a pass-through centre, so the panel can be
// docked to any edge while the render shows through the middle.
@@ -130,9 +329,8 @@ namespace Donut
ImGui::SetNextWindowSize(ImVec2(340, 580), ImGuiCond_FirstUseEver);
ImGui::Begin("Donut \xc2\xb7 Black Hole");
- // --- header: device + performance -----------------------------------
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();
@@ -155,29 +353,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");
@@ -203,15 +400,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();
@@ -225,14 +421,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)
@@ -242,27 +436,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);
@@ -286,115 +479,30 @@ namespace Donut
dispatcher.dispatch<WindowResizeEvent>([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<KeyPressedEvent>([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
- {
- // (Logger, settings and API selection happen in the constructor.) Both
- // backends run the SAME application through the RendererBackend interface,
- // so the app behaves identically regardless of the active graphics API.
- 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<VulkanRenderer>();
- else
- m_renderer = create_scope<OpenGLRenderer>();
-
- 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)
+ if (m_device)
{
- m_renderer->shutdown();
- m_renderer.reset();
- }
- else
- {
- 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();
+ // Free HDRIManager's cached GPU textures now, while the render context
+ // is still alive. On OpenGL these are GL textures owned by a static
+ // singleton; letting them destruct at program exit would call
+ // glDeleteTextures after the GL context is gone and crash on close.
+ 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);
- }
};