From 7d39ee93a6d354e727c7534a18663f1d00d46b0f Mon Sep 17 00:00:00 2001 From: hachem Date: Thu, 20 Aug 2026 01:57:44 +0200 Subject: refactor: trailing return types in core --- src/core/application.cpp | 34 ++++----- src/core/application.h | 32 ++++---- src/core/camera.cpp | 44 +++++------ src/core/camera.h | 169 +++++++++++++++++++++--------------------- src/core/event.h | 134 ++++++++++++++++----------------- src/core/hdri_manager.cpp | 14 ++-- src/core/hdri_manager.h | 23 +++--- src/core/log.cpp | 64 ++++++++-------- src/core/log.h | 63 ++++++++-------- src/core/memory.h | 14 ++-- src/core/settings_manager.cpp | 16 ++-- src/core/settings_manager.h | 86 ++++++++++----------- src/core/state.h | 14 ++-- src/core/state_manager.cpp | 22 +++--- src/core/state_manager.h | 39 +++++----- src/core/theme_manager.cpp | 8 +- src/core/theme_manager.h | 14 ++-- src/core/window.cpp | 80 ++++++++++---------- src/core/window.h | 66 +++++++++-------- 19 files changed, 473 insertions(+), 463 deletions(-) diff --git a/src/core/application.cpp b/src/core/application.cpp index 0f07979..11c7bd0 100644 --- a/src/core/application.cpp +++ b/src/core/application.cpp @@ -53,7 +53,7 @@ namespace Donut s_instance = nullptr; } - void Application::run() + auto Application::run() -> void { while (m_running) { @@ -76,7 +76,7 @@ namespace Donut } } - void Application::build_vulkan_ui() + auto Application::build_vulkan_ui() -> void { ImGui::Begin("Donut - Vulkan backend"); ImGui::Text("Geodesic black hole through Vulkan (MoltenVK)."); @@ -87,22 +87,22 @@ namespace Donut ImGui::End(); } - void Application::close() + auto Application::close() -> void { m_running = false; } - void Application::on_event(Event& event) + auto Application::on_event(Event& event) -> void { EventDispatcher dispatcher(event); - dispatcher.dispatch([this, &event](WindowCloseEvent& e) + dispatcher.dispatch([this, &event](WindowCloseEvent& e) { m_running = false; event.handled = true; return true; }); - - dispatcher.dispatch([this, &event](WindowResizeEvent& e) + + dispatcher.dispatch([this, &event](WindowResizeEvent& e) { if (e.get_width() == 0 || e.get_height() == 0) m_minimized = true; @@ -121,7 +121,7 @@ namespace Donut event.handled = true; return true; }); - + dispatcher.dispatch([this, &event](KeyPressedEvent& e) { if (!m_state_manager) @@ -144,7 +144,7 @@ namespace Donut event.handled = true; return true; } - + return true; }); @@ -152,7 +152,7 @@ namespace Donut m_state_manager->on_event(event); } - void Application::on_init() + auto Application::on_init() -> void { if (RendererAPI::get_api() == RendererAPI::API::Vulkan) { @@ -182,7 +182,7 @@ namespace Donut m_state_manager->switch_to_state("Config"); } - void Application::on_shutdown() + auto Application::on_shutdown() -> void { if (m_vulkan_renderer) { @@ -199,7 +199,7 @@ namespace Donut Logger::shutdown(); } - void Application::on_update() + auto Application::on_update() -> void { float current_frame = (float)glfwGetTime(); m_delta_time = current_frame - m_last_frame; @@ -208,20 +208,20 @@ namespace Donut m_state_manager->update(m_delta_time); } - void Application::on_render() + 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(); } - - void Application::setup_docking_layout() + + 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 3c76dcc..df6669b 100644 --- a/src/core/application.h +++ b/src/core/application.h @@ -15,25 +15,27 @@ namespace Donut class Application { public: - Application(const std::string& name = "Donut", + Application(const std::string& name = "Donut", int width = 1280, int height = 720); ~Application(); - void run(); - void close(); + 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; } - Window& get_window() { return *m_window; } - StateManager& get_state_manager() { return *m_state_manager; } - Engine& get_engine() { return *m_engine; } - static Application& get() { return *s_instance; } private: - void on_init(); - void on_shutdown(); - void on_update(); - void on_render(); - void on_event(Event& event); - void setup_docking_layout(); - void build_vulkan_ui(); + 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_vulkan_ui() -> void; + private: Scope m_state_manager; Scope m_window; @@ -42,7 +44,7 @@ namespace Donut bool m_running; bool m_minimized; - + float m_delta_time = 0.0f; float m_last_frame = 0.0f; diff --git a/src/core/camera.cpp b/src/core/camera.cpp index 9c2b061..35b7a2f 100644 --- a/src/core/camera.cpp +++ b/src/core/camera.cpp @@ -12,7 +12,7 @@ namespace Donut recalculate_view_matrix(); } - void Camera::set_projection(float fov, float aspect_ratio, float near_plane, float far_plane) + auto Camera::set_projection(float fov, float aspect_ratio, float near_plane, float far_plane) -> void { m_fov = fov; m_aspect_ratio = aspect_ratio; @@ -21,13 +21,13 @@ namespace Donut recalculate_projection_matrix(); } - void Camera::recalculate_projection_matrix() + auto Camera::recalculate_projection_matrix() -> void { m_projection_matrix = glm::perspective(glm::radians(m_fov), m_aspect_ratio, m_near_plane, m_far_plane); m_view_projection_matrix = m_projection_matrix * m_view_matrix; } - void Camera::recalculate_view_matrix() + auto Camera::recalculate_view_matrix() -> void { if (m_camera_mode == CameraMode::FPS) { @@ -45,7 +45,7 @@ namespace Donut glm::vec3 right = glm::normalize(glm::cross(front, world_up)); glm::vec3 up = glm::normalize(glm::cross(right, front)); - m_view_matrix = glm::lookAt(m_position, m_position + front, up); + m_view_matrix = glm::lookAt(m_position, m_position + front, up); m_view_projection_matrix = m_projection_matrix * m_view_matrix; } else if (m_camera_mode == CameraMode::Orbital) @@ -53,13 +53,13 @@ namespace Donut glm::vec3 position = get_orbital_position(); glm::vec3 target = m_orbital_target; glm::vec3 up(0.0f, 1.0f, 0.0f); - + m_view_matrix = glm::lookAt(position, target, up); m_view_projection_matrix = m_projection_matrix * m_view_matrix; } } - glm::vec3 Camera::get_forward_direction() const + auto Camera::get_forward_direction() const -> glm::vec3 { float pitch = glm::radians(m_rotation.x); float yaw = glm::radians(m_rotation.y); @@ -72,18 +72,18 @@ namespace Donut return glm::normalize(direction); } - glm::vec3 Camera::get_right_direction() const + auto Camera::get_right_direction() const -> glm::vec3 { glm::vec3 world_up(0.0f, 1.0f, 0.0f); return glm::normalize(glm::cross(get_forward_direction(), world_up)); } - glm::vec3 Camera::get_up_direction() const + auto Camera::get_up_direction() const -> glm::vec3 { return glm::normalize(glm::cross(get_right_direction(), get_forward_direction())); } - void Camera::on_mouse_move(float x_offset, float y_offset, bool constrain_pitch) + auto Camera::on_mouse_move(float x_offset, float y_offset, bool constrain_pitch) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -105,7 +105,7 @@ namespace Donut } } - void Camera::move_forward(float delta_time) + auto Camera::move_forward(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -114,7 +114,7 @@ namespace Donut } } - void Camera::move_backward(float delta_time) + auto Camera::move_backward(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -123,7 +123,7 @@ namespace Donut } } - void Camera::move_right(float delta_time) + auto Camera::move_right(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -132,7 +132,7 @@ namespace Donut } } - void Camera::move_left(float delta_time) + auto Camera::move_left(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -141,7 +141,7 @@ namespace Donut } } - void Camera::move_up(float delta_time) + auto Camera::move_up(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -151,7 +151,7 @@ namespace Donut } } - void Camera::move_down(float delta_time) + auto Camera::move_down(float delta_time) -> void { if (m_camera_mode == CameraMode::FPS) { @@ -161,7 +161,7 @@ namespace Donut } } - glm::vec3 Camera::get_orbital_position() const + auto Camera::get_orbital_position() const -> glm::vec3 { float clamped_elevation = glm::clamp(m_elevation, 0.01f, float(std::numbers::pi) - 0.01f); return glm::vec3 @@ -172,7 +172,7 @@ namespace Donut ); } - void Camera::update_orbital() + auto Camera::update_orbital() -> void { m_orbital_target = glm::vec3(0.0f, 0.0f, 0.0f); if (m_dragging || m_panning) @@ -182,24 +182,24 @@ namespace Donut recalculate_view_matrix(); } - void Camera::process_orbital_mouse_move(double x, double y) + auto Camera::process_orbital_mouse_move(double x, double y) -> void { if (m_dragging && !m_panning) { float dx = float(x - m_last_x_orbital); float dy = float(y - m_last_y_orbital); - + m_azimuth += dx * m_orbital_speed; m_elevation -= dy * m_orbital_speed; m_elevation = glm::clamp(m_elevation, 0.01f, float(std::numbers::pi) - 0.01f); } - + m_last_x_orbital = x; m_last_y_orbital = y; update_orbital(); } - void Camera::process_orbital_mouse_button(int button, int action, int mods) + auto Camera::process_orbital_mouse_button(int button, int action, int mods) -> void { if (button == GLFW_MOUSE_BUTTON_LEFT) { @@ -216,7 +216,7 @@ namespace Donut } } - void Camera::process_orbital_scroll(double x_offset, double y_offset) + auto Camera::process_orbital_scroll(double x_offset, double y_offset) -> void { m_orbital_radius -= y_offset * m_zoom_speed; m_orbital_radius = glm::clamp(m_orbital_radius, m_orbital_min_radius, m_orbital_max_radius); diff --git a/src/core/camera.h b/src/core/camera.h index 677cb71..c997c35 100644 --- a/src/core/camera.h +++ b/src/core/camera.h @@ -16,85 +16,86 @@ namespace Donut class Camera { public: - Camera(float fov = 45.0f, float aspect_ratio = 16.0f / 9.0f, + Camera(float fov = 45.0f, float aspect_ratio = 16.0f / 9.0f, float near_plane = 0.1f, float far_plane = 100.0f); ~Camera() = default; - void set_position(const glm::vec3& position) { m_position = position; recalculate_view_matrix(); } - void set_rotation(const glm::vec3& rotation) { m_rotation = rotation; recalculate_view_matrix(); } - - const glm::vec3& get_position() const { return m_position; } - const glm::vec3& get_rotation() const { return m_rotation; } - - glm::vec3 get_forward_direction() const; - glm::vec3 get_right_direction() const; - glm::vec3 get_up_direction() const; - - const glm::mat4& get_projection_matrix() const { return m_projection_matrix; } - const glm::mat4& get_view_matrix() const { return m_view_matrix; } - const glm::mat4& get_view_projection_matrix() const { return m_view_projection_matrix; } - - void set_projection(float fov, float aspect_ratio, float near_plane, float far_plane); - void on_mouse_move(float x_offset, float y_offset, bool constrain_pitch = true); - - void move_forward(float delta_time); - void move_backward(float delta_time); - void move_right(float delta_time); - void move_left(float delta_time); - void move_up(float delta_time); - void move_down(float delta_time); - - void set_mouse_sensitivity(float sensitivity) { m_mouse_sensitivity = sensitivity; } - float get_mouse_sensitivity() const { return m_mouse_sensitivity; } - - void set_movement_speed(float speed) { m_movement_speed = speed; } - float get_movement_speed() const { return m_movement_speed; } - - void set_orbital_target(const glm::vec3& target) { m_orbital_target = target; } - const glm::vec3& get_orbital_target() const { return m_orbital_target; } - - void set_orbital_radius(double radius) { m_orbital_radius = radius; } - double get_orbital_radius() const { return m_orbital_radius; } - - void set_orbital_limits(double min_radius, double max_radius) - { - m_orbital_min_radius = min_radius; - m_orbital_max_radius = max_radius; + auto set_position(const glm::vec3& position) -> void { m_position = position; recalculate_view_matrix(); } + auto set_rotation(const glm::vec3& rotation) -> void { m_rotation = rotation; recalculate_view_matrix(); } + + auto get_position() const -> const glm::vec3& { return m_position; } + auto get_rotation() const -> const glm::vec3& { return m_rotation; } + + auto get_forward_direction() const -> glm::vec3; + auto get_right_direction() const -> glm::vec3; + auto get_up_direction() const -> glm::vec3; + + auto get_projection_matrix() const -> const glm::mat4& { return m_projection_matrix; } + auto get_view_matrix() const -> const glm::mat4& { return m_view_matrix; } + auto get_view_projection_matrix() const -> const glm::mat4& { return m_view_projection_matrix; } + + auto set_projection(float fov, float aspect_ratio, float near_plane, float far_plane) -> void; + auto on_mouse_move(float x_offset, float y_offset, bool constrain_pitch = true) -> void; + + auto move_forward(float delta_time) -> void; + auto move_backward(float delta_time) -> void; + auto move_right(float delta_time) -> void; + auto move_left(float delta_time) -> void; + auto move_up(float delta_time) -> void; + auto move_down(float delta_time) -> void; + + auto set_mouse_sensitivity(float sensitivity) -> void { m_mouse_sensitivity = sensitivity; } + auto get_mouse_sensitivity() const -> float { return m_mouse_sensitivity; } + + auto set_movement_speed(float speed) -> void { m_movement_speed = speed; } + auto get_movement_speed() const -> float { return m_movement_speed; } + + auto set_orbital_target(const glm::vec3& target) -> void { m_orbital_target = target; } + auto get_orbital_target() const -> const glm::vec3& { return m_orbital_target; } + + auto set_orbital_radius(double radius) -> void { m_orbital_radius = radius; } + auto get_orbital_radius() const -> double { return m_orbital_radius; } + + auto set_orbital_limits(double min_radius, double max_radius) -> void + { + m_orbital_min_radius = min_radius; + m_orbital_max_radius = max_radius; } - - void set_orbital_speed(float speed) { m_orbital_speed = speed; } - float get_orbital_speed() const { return m_orbital_speed; } - - void set_zoom_speed(double speed) { m_zoom_speed = speed; } - double get_zoom_speed() const { return m_zoom_speed; } - - void set_azimuth(float azimuth) { m_azimuth = azimuth; } - float get_azimuth() const { return m_azimuth; } - - void set_elevation(float elevation) { m_elevation = elevation; } - float get_elevation() const { return m_elevation; } - - glm::vec3 get_orbital_position() const; - void update_orbital(); - void process_orbital_mouse_move(double x, double y); - void process_orbital_mouse_button(int button, int action, int mods); - void process_orbital_scroll(double x_offset, double y_offset); - - void set_camera_mode(CameraMode mode) { m_camera_mode = mode; } - CameraMode get_camera_mode() const { return m_camera_mode; } - - bool is_dragging() const { return m_dragging; } - bool is_panning() const { return m_panning; } - bool is_moving() const { return m_moving; } - double get_last_x() const { return m_last_x; } - double get_last_y() const { return m_last_y; } + + auto set_orbital_speed(float speed) -> void { m_orbital_speed = speed; } + auto get_orbital_speed() const -> float { return m_orbital_speed; } + + auto set_zoom_speed(double speed) -> void { m_zoom_speed = speed; } + auto get_zoom_speed() const -> double { return m_zoom_speed; } + + auto set_azimuth(float azimuth) -> void { m_azimuth = azimuth; } + auto get_azimuth() const -> float { return m_azimuth; } + + auto set_elevation(float elevation) -> void { m_elevation = elevation; } + auto get_elevation() const -> float { return m_elevation; } + + auto get_orbital_position() const -> glm::vec3; + auto update_orbital() -> void; + auto process_orbital_mouse_move(double x, double y) -> void; + auto process_orbital_mouse_button(int button, int action, int mods) -> void; + auto process_orbital_scroll(double x_offset, double y_offset) -> void; + + auto set_camera_mode(CameraMode mode) -> void { m_camera_mode = mode; } + auto get_camera_mode() const -> CameraMode { return m_camera_mode; } + + auto is_dragging() const -> bool { return m_dragging; } + auto is_panning() const -> bool { return m_panning; } + auto is_moving() const -> bool { return m_moving; } + auto get_last_x() const -> double { return m_last_x; } + auto get_last_y() const -> double { return m_last_y; } private: - void recalculate_view_matrix(); - void recalculate_projection_matrix(); + auto recalculate_view_matrix() -> void; + auto recalculate_projection_matrix() -> void; + private: CameraMode m_camera_mode = CameraMode::FPS; - + glm::mat4 m_projection_matrix; glm::mat4 m_view_matrix; glm::mat4 m_view_projection_matrix; @@ -102,7 +103,7 @@ namespace Donut glm::vec3 m_position = { 0.0f, 0.0f, 3.0f }; glm::vec3 m_rotation = { 0.0f, 0.0f, 0.0f }; - float m_fov = 45.0f; + float m_fov = 45.0f; float m_aspect_ratio = 16.0f / 9.0f; float m_near_plane = 0.1f; float m_far_plane = 100.0f; @@ -112,19 +113,19 @@ namespace Donut bool m_first_mouse = true; float m_last_x = 0.0f; float m_last_y = 0.0f; - - glm::vec3 m_orbital_target = glm::vec3(0.0f, 0.0f, 0.0f); - double m_orbital_radius = 6.34194e10; + + glm::vec3 m_orbital_target = glm::vec3(0.0f, 0.0f, 0.0f); + double m_orbital_radius = 6.34194e10; double m_orbital_min_radius = 1e10; double m_orbital_max_radius = 1e12; - float m_azimuth = 0.0f; - float m_elevation = static_cast(std::numbers::pi) / 2.0f; - float m_orbital_speed = 0.01f; - double m_zoom_speed = 25e9f; - bool m_dragging = false; - bool m_panning = false; - bool m_moving = false; - double m_last_x_orbital = 0.0; - double m_last_y_orbital = 0.0; + float m_azimuth = 0.0f; + float m_elevation = static_cast(std::numbers::pi) / 2.0f; + float m_orbital_speed = 0.01f; + double m_zoom_speed = 25e9f; + bool m_dragging = false; + bool m_panning = false; + bool m_moving = false; + double m_last_x_orbital = 0.0; + double m_last_y_orbital = 0.0; }; } diff --git a/src/core/event.h b/src/core/event.h index a1e30e9..1891206 100644 --- a/src/core/event.h +++ b/src/core/event.h @@ -46,40 +46,40 @@ namespace Donut public: virtual ~Event() = default; - bool handled = false; + virtual auto get_event_type() const -> EventType = 0; + virtual auto get_name() const -> const char* = 0; + virtual auto get_category_flags() const -> int = 0; + virtual auto to_string() const -> std::string { return get_name(); } - virtual EventType get_event_type() const = 0; - virtual const char* get_name() const = 0; - virtual int get_category_flags() const = 0; - virtual std::string to_string() const { return get_name(); } + auto is_in_category(EventCategory category) -> bool { return get_category_flags() & category; } - bool is_in_category(EventCategory category) { return get_category_flags() & category; } + bool handled = false; }; - #define EVENT_CLASS_TYPE(type) \ - static EventType get_static_type() { return EventType::type; } \ - virtual EventType get_event_type() const override { return get_static_type(); } \ - virtual const char* get_name() const override { return #type; } - + #define EVENT_CLASS_TYPE(type) \ + static auto get_static_type() -> EventType { return EventType::type; } \ + virtual auto get_event_type() const -> EventType override { return get_static_type(); } \ + virtual auto get_name() const -> const char* override { return #type; } + #define APPLICATION_EVENT_CLASS_TYPE(type) \ EVENT_CLASS_TYPE(type) \ - virtual int get_category_flags() const override { return EventCategoryApplication; } - + virtual auto get_category_flags() const -> int override { return EventCategoryApplication; } + #define MOUSE_EVENT_CLASS_TYPE(type) \ EVENT_CLASS_TYPE(type) \ - virtual int get_category_flags() const override { return EventCategoryMouse | \ - EventCategoryInput; } - + virtual auto get_category_flags() const -> int override { return EventCategoryMouse | \ + EventCategoryInput; } + #define MOUSE_BUTTON_EVENT_CLASS_TYPE(type) \ EVENT_CLASS_TYPE(type) \ - virtual int get_category_flags() const override { return EventCategoryMouseButton | \ - EventCategoryMouse | \ - EventCategoryInput; } - + virtual auto get_category_flags() const -> int override { return EventCategoryMouseButton | \ + EventCategoryMouse | \ + EventCategoryInput; } + #define KEYBOARD_EVENT_CLASS_TYPE(type) \ EVENT_CLASS_TYPE(type) \ - virtual int get_category_flags() const override { return EventCategoryKeyboard | \ - EventCategoryInput; } + virtual auto get_category_flags() const -> int override { return EventCategoryKeyboard | \ + EventCategoryInput; } class WindowResizeEvent : public Event @@ -88,10 +88,10 @@ namespace Donut WindowResizeEvent(unsigned int width, unsigned int height) : m_width(width), m_height(height) { } - unsigned int get_width() const { return m_width; } - unsigned int get_height() const { return m_height; } + auto get_width() const -> unsigned int { return m_width; } + auto get_height() const -> unsigned int { return m_height; } - std::string to_string() const override + auto to_string() const -> std::string override { return "WindowResizeEvent: " + std::to_string(m_width) + ", " + std::to_string(m_height); } @@ -102,7 +102,7 @@ namespace Donut unsigned int m_width, m_height; }; - class WindowCloseEvent + class WindowCloseEvent : public Event { public: @@ -110,7 +110,7 @@ namespace Donut APPLICATION_EVENT_CLASS_TYPE(WindowClose) }; - class WindowFocusEvent + class WindowFocusEvent : public Event { public: @@ -118,7 +118,7 @@ namespace Donut APPLICATION_EVENT_CLASS_TYPE(WindowFocus) }; - class WindowLostFocusEvent + class WindowLostFocusEvent : public Event { public: @@ -126,17 +126,17 @@ namespace Donut APPLICATION_EVENT_CLASS_TYPE(WindowLostFocus) }; - class WindowMovedEvent + class WindowMovedEvent : public Event { public: WindowMovedEvent(int x, int y) : m_x(x), m_y(y) { } - int get_x() const { return m_x; } - int get_y() const { return m_y; } + auto get_x() const -> int { return m_x; } + auto get_y() const -> int { return m_y; } - std::string to_string() const override + auto to_string() const -> std::string override { return "WindowMovedEvent: " + std::to_string(m_x) + ", " + std::to_string(m_y); } @@ -147,13 +147,13 @@ namespace Donut int m_x, m_y; }; - class KeyEvent + class KeyEvent : public Event { public: - int get_key_code() const { return m_key_code; } - virtual int get_category_flags() const override { return EventCategoryKeyboard | - EventCategoryInput; } + auto get_key_code() const -> int { return m_key_code; } + virtual auto get_category_flags() const -> int override { return EventCategoryKeyboard | + EventCategoryInput; } protected: KeyEvent(int keycode) @@ -161,18 +161,18 @@ namespace Donut int m_key_code; }; - class KeyPressedEvent + class KeyPressedEvent : public KeyEvent { public: KeyPressedEvent(int keycode, bool is_repeat = false) : KeyEvent(keycode), m_is_repeat(is_repeat) { } - bool is_repeat() const { return m_is_repeat; } + auto is_repeat() const -> bool { return m_is_repeat; } - std::string to_string() const override + auto to_string() const -> std::string override { - return "KeyPressedEvent: " + std::to_string(m_key_code) + + return "KeyPressedEvent: " + std::to_string(m_key_code) + " (repeat = " + std::to_string(m_is_repeat) + ")"; } @@ -182,14 +182,14 @@ namespace Donut bool m_is_repeat; }; - class KeyReleasedEvent + class KeyReleasedEvent : public KeyEvent { public: KeyReleasedEvent(int keycode) : KeyEvent(keycode) { } - std::string to_string() const override + auto to_string() const -> std::string override { return "KeyReleasedEvent: " + std::to_string(m_key_code); } @@ -197,14 +197,14 @@ namespace Donut KEYBOARD_EVENT_CLASS_TYPE(KeyReleased) }; - class KeyTypedEvent + class KeyTypedEvent : public KeyEvent { public: KeyTypedEvent(int keycode) : KeyEvent(keycode) { } - std::string to_string() const override + auto to_string() const -> std::string override { return "KeyTypedEvent: " + std::to_string(m_key_code); } @@ -212,17 +212,17 @@ namespace Donut KEYBOARD_EVENT_CLASS_TYPE(KeyTyped) }; - class MouseMovedEvent + class MouseMovedEvent : public Event { public: MouseMovedEvent(float x, float y) : m_mouse_x(x), m_mouse_y(y) { } - float get_x() const { return m_mouse_x; } - float get_y() const { return m_mouse_y; } + auto get_x() const -> float { return m_mouse_x; } + auto get_y() const -> float { return m_mouse_y; } - std::string to_string() const override + auto to_string() const -> std::string override { return "MouseMovedEvent: " + std::to_string(m_mouse_x) + ", " + std::to_string(m_mouse_y); } @@ -233,17 +233,17 @@ namespace Donut float m_mouse_x, m_mouse_y; }; - class MouseScrolledEvent + class MouseScrolledEvent : public Event { public: MouseScrolledEvent(float x_offset, float y_offset) : m_x_offset(x_offset), m_y_offset(y_offset) { } - float get_x_offset() const { return m_x_offset; } - float get_y_offset() const { return m_y_offset; } + auto get_x_offset() const -> float { return m_x_offset; } + auto get_y_offset() const -> float { return m_y_offset; } - std::string to_string() const override + auto to_string() const -> std::string override { return "MouseScrolledEvent: " + std::to_string(m_x_offset) + ", " + std::to_string(m_y_offset); @@ -255,14 +255,14 @@ namespace Donut float m_x_offset, m_y_offset; }; - class MouseButtonEvent + class MouseButtonEvent : public Event { public: - int get_mouse_button() const { return m_button; } - virtual int get_category_flags() const override { return EventCategoryMouseButton | - EventCategoryMouse | - EventCategoryInput; } + auto get_mouse_button() const -> int { return m_button; } + virtual auto get_category_flags() const -> int override { return EventCategoryMouseButton | + EventCategoryMouse | + EventCategoryInput; } protected: MouseButtonEvent(int button) @@ -270,14 +270,14 @@ namespace Donut int m_button; }; - class MouseButtonPressedEvent + class MouseButtonPressedEvent : public MouseButtonEvent { public: MouseButtonPressedEvent(int button) : MouseButtonEvent(button) { } - std::string to_string() const override + auto to_string() const -> std::string override { return "MouseButtonPressedEvent: " + std::to_string(m_button); } @@ -285,14 +285,14 @@ namespace Donut MOUSE_BUTTON_EVENT_CLASS_TYPE(MouseButtonPressed) }; - class MouseButtonReleasedEvent + class MouseButtonReleasedEvent : public MouseButtonEvent { public: MouseButtonReleasedEvent(int button) : MouseButtonEvent(button) { } - std::string to_string() const override + auto to_string() const -> std::string override { return "MouseButtonReleasedEvent: " + std::to_string(m_button); } @@ -303,11 +303,11 @@ namespace Donut class EventDispatcher { public: - EventDispatcher(Event& event) + EventDispatcher(Event& event) : m_event(event) { } template - bool dispatch(const F& func) + auto dispatch(const F& func) -> bool { if (m_event.get_event_type() == T::get_static_type()) { @@ -329,21 +329,21 @@ namespace Donut EventHandler() = default; ~EventHandler() = default; - void set_event_callback(const EventCallbackFn& callback) + auto set_event_callback(const EventCallbackFn& callback) -> void { m_event_callback = callback; } - void on_event(Event& event) + auto on_event(Event& event) -> void { if (m_event_callback) m_event_callback(event); } template - void bind_event(const std::function& callback) + auto bind_event(const std::function& callback) -> void { - m_event_callback = [callback](Event& event) + m_event_callback = [callback](Event& event) { if (event.get_event_type() == T::get_static_type()) callback(static_cast(event)); diff --git a/src/core/hdri_manager.cpp b/src/core/hdri_manager.cpp index 1a5521e..605dcf6 100644 --- a/src/core/hdri_manager.cpp +++ b/src/core/hdri_manager.cpp @@ -3,7 +3,7 @@ namespace Donut { - Ref HDRIManager::load_hdri(const std::string& path) + auto HDRIManager::load_hdri(const std::string& path) -> Ref { auto it = m_hdri_cache.find(path); if (it != m_hdri_cache.end()) @@ -14,7 +14,7 @@ namespace Donut DONUT_INFO("Loading HDRI: {}", path); auto hdri = CubemapTexture::create_from_hdri(path); - + if (hdri) { m_hdri_cache[path] = hdri; @@ -26,7 +26,7 @@ namespace Donut return hdri; } - void HDRIManager::set_current_hdri(const std::string& path) + auto HDRIManager::set_current_hdri(const std::string& path) -> void { auto hdri = load_hdri(path); if (hdri) @@ -38,12 +38,12 @@ namespace Donut DONUT_ERROR("Failed to set current HDRI: {}", path); } - std::string HDRIManager::get_hdri_name(const std::string& path) const + auto HDRIManager::get_hdri_name(const std::string& path) const -> std::string { std::filesystem::path file_path(path); std::string filename = file_path.stem().string(); std::string name = filename; - + for (size_t i = 0; i < name.length(); ++i) { if (name[i] == '_') @@ -51,11 +51,11 @@ namespace Donut else if (i == 0 || name[i-1] == ' ') name[i] = std::toupper(name[i]); } - + return name; } - void HDRIManager::clear_cache() + auto HDRIManager::clear_cache() -> void { m_hdri_cache.clear(); m_current_hdri.reset(); diff --git a/src/core/hdri_manager.h b/src/core/hdri_manager.h index 3bdf1cb..d98830f 100644 --- a/src/core/hdri_manager.h +++ b/src/core/hdri_manager.h @@ -12,19 +12,20 @@ namespace Donut class HDRIManager { public: - static HDRIManager& get() + static auto get() -> HDRIManager& { static HDRIManager instance; return instance; } - Ref load_hdri(const std::string& path); - Ref get_current_hdri() const { return m_current_hdri; } - - void set_current_hdri(const std::string& path); - const std::vector& get_available_hdri() const { return m_available_hdri; } - std::string get_hdri_name(const std::string& path) const; - void clear_cache(); + auto load_hdri(const std::string& path) -> Ref; + auto get_current_hdri() const -> Ref { return m_current_hdri; } + + auto set_current_hdri(const std::string& path) -> void; + auto get_available_hdri() const -> const std::vector& { return m_available_hdri; } + auto get_hdri_name(const std::string& path) const -> std::string; + auto clear_cache() -> void; + private: HDRIManager() = default; ~HDRIManager() = default; @@ -33,10 +34,10 @@ namespace Donut HDRIManager& operator=(const HDRIManager&) = delete; std::unordered_map> m_hdri_cache; - + Ref m_current_hdri; - - std::vector m_available_hdri = + + std::vector m_available_hdri = { "assets/hdri/hdr_blue_nebulae_1.hdr", "assets/hdri/hdr_subdued_blue_nebulae.hdr", diff --git a/src/core/log.cpp b/src/core/log.cpp index 0411e20..5a0434f 100644 --- a/src/core/log.cpp +++ b/src/core/log.cpp @@ -6,68 +6,68 @@ #include #endif -namespace Donut +namespace Donut { Ref Logger::s_logger; - void Logger::init() + auto Logger::init() -> void { s_logger = create_ref(); s_logger->set_log_level(LogLevel::Info); s_logger->enable_console_output(true); s_logger->enable_file_output(true); s_logger->set_log_file("logs/donut.log"); - + s_logger->log_message(LogLevel::Info, "Logging system initialized"); } - void Logger::shutdown() + auto Logger::shutdown() -> void { if (s_logger) s_logger->log_message(LogLevel::Info, "Shutting down logging system"); s_logger.reset(); } - Ref Logger::get_logger() + auto Logger::get_logger() -> Ref { return s_logger; } Logger::Logger() - : m_log_level(LogLevel::Info), - m_console_output(true), + : m_log_level(LogLevel::Info), + m_console_output(true), m_file_output(false) { } - Logger::~Logger() + Logger::~Logger() { if (m_log_file.is_open()) m_log_file.close(); } - void Logger::set_log_file(const std::string& filename) + auto Logger::set_log_file(const std::string& filename) -> void { std::filesystem::path log_path(filename); std::filesystem::create_directories(log_path.parent_path()); - + m_log_file.open(filename, std::ios::app); if (!m_log_file.is_open()) std::cerr << "Failed to open log file: " << filename << std::endl; } - std::string Logger::get_time_stamp() + auto Logger::get_time_stamp() -> std::string { auto now = std::chrono::system_clock::now(); - auto time_t = std::chrono::system_clock::to_time_t(now); - + auto time = std::chrono::system_clock::to_time_t(now); + std::stringstream ss; - ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S"); - + ss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S"); + return ss.str(); } - std::string Logger::get_log_level_string(LogLevel level) + auto Logger::get_log_level_string(LogLevel level) -> std::string { - switch (level) + switch (level) { case LogLevel::trace: return "TRACE"; case LogLevel::Info: return "INFO"; @@ -78,43 +78,43 @@ namespace Donut } } - void Logger::set_console_color(LogLevel level) + auto Logger::set_console_color(LogLevel level) -> void { #if defined(DONUT_WINDOWS) HANDLE h_console = GetStdHandle(STD_OUTPUT_HANDLE); WORD color; - + switch (level) { case LogLevel::trace: color = FOREGROUND_RED | - FOREGROUND_GREEN | + FOREGROUND_GREEN | FOREGROUND_BLUE; break; case LogLevel::Info: - color = FOREGROUND_GREEN | + color = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break; case LogLevel::Warn: - color = FOREGROUND_RED | - FOREGROUND_GREEN | + color = FOREGROUND_RED | + FOREGROUND_GREEN | FOREGROUND_INTENSITY; break; case LogLevel::Err: - color = FOREGROUND_RED | + color = FOREGROUND_RED | FOREGROUND_INTENSITY; break; case LogLevel::Fatal: - color = FOREGROUND_RED | - FOREGROUND_BLUE | + color = FOREGROUND_RED | + FOREGROUND_BLUE | FOREGROUND_INTENSITY; break; default: - color = FOREGROUND_RED | - FOREGROUND_GREEN | + color = FOREGROUND_RED | + FOREGROUND_GREEN | FOREGROUND_BLUE; break; } - + SetConsoleTextAttribute(h_console, color); #else const char* color_code; @@ -142,12 +142,12 @@ namespace Donut #endif } - void Logger::reset_console_color() + auto Logger::reset_console_color() -> void { #if defined(DONUT_WINDOWS) HANDLE h_console = GetStdHandle(STD_OUTPUT_HANDLE); - SetConsoleTextAttribute(h_console, FOREGROUND_RED | - FOREGROUND_GREEN | + SetConsoleTextAttribute(h_console, FOREGROUND_RED | + FOREGROUND_GREEN | FOREGROUND_BLUE); #else std::cout << "\033[0m"; diff --git a/src/core/log.h b/src/core/log.h index 1477226..db6b4b4 100644 --- a/src/core/log.h +++ b/src/core/log.h @@ -23,67 +23,70 @@ namespace Donut Fatal = 5 }; - class Logger + class Logger { public: - static void init(); - static void shutdown(); + Logger(); + ~Logger(); + + static auto init() -> void; + static auto shutdown() -> void; - static Ref get_logger(); + static auto get_logger() -> Ref; template - static void trace(const std::string_view& format, const Args&... args) + static auto trace(const std::string_view& format, const Args&... args) -> void { auto logger = get_logger(); if (logger) logger->log_message(LogLevel::trace, format, args...); } template - static void info(const std::string_view& format, const Args&... args) + static auto info(const std::string_view& format, const Args&... args) -> void { auto logger = get_logger(); if (logger) logger->log_message(LogLevel::Info, format, args...); } template - static void warn(const std::string_view& format, const Args&... args) + static auto warn(const std::string_view& format, const Args&... args) -> void { auto logger = get_logger(); if (logger) logger->log_message(LogLevel::Warn, format, args...); } template - static void error(const std::string_view& format, const Args&... args) + static auto error(const std::string_view& format, const Args&... args) -> void { auto logger = get_logger(); if (logger) logger->log_message(LogLevel::Err, format, args...); } template - static void fatal(const std::string_view& format, const Args&... args) + static auto fatal(const std::string_view& format, const Args&... args) -> void { auto logger = get_logger(); if (logger) logger->log_message(LogLevel::Fatal, format, args...); } template - void log_message(LogLevel level, const std::string_view& format, const Args&... args) + auto log_message(LogLevel level, const std::string_view& format, const Args&... args) -> void { - if (level < m_log_level) + if (level < m_log_level) return; std::lock_guard lock(m_mutex); std::string message = format_string(format, args...); std::string full_message = get_time_stamp() + " [" + get_log_level_string(level) + "] " + message; - - if (m_console_output) + + if (m_console_output) { set_console_color(level); std::cout << full_message << std::endl; reset_console_color(); } - - if (m_file_output && m_log_file.is_open()) + + if (m_file_output && m_log_file.is_open()) { m_log_file << full_message << std::endl; m_log_file.flush(); @@ -91,44 +94,42 @@ namespace Donut } template - std::string format_string(const std::string_view& format, const Args&... args) + auto format_string(const std::string_view& format, const Args&... args) -> std::string { std::string result = format.data(); std::vector arg_strings = { to_string(args)... }; - + size_t arg_index = 0; size_t pos = 0; - + while ((pos = result.find("{}", pos)) != std::string::npos && arg_index < arg_strings.size()) { result.replace(pos, 2, arg_strings[arg_index]); pos += arg_strings[arg_index].length(); arg_index++; } - + return result; } template - std::string to_string(const T& value) + auto to_string(const T& value) -> std::string { std::stringstream ss; ss << value; return ss.str(); } - void set_log_level(LogLevel level) { m_log_level = level; } - void enable_console_output(bool enable) { m_console_output = enable; } - void enable_file_output(bool enable) { m_file_output = enable; } - void set_log_file(const std::string& filename); - public: - Logger(); - ~Logger(); + auto set_log_level(LogLevel level) -> void { m_log_level = level; } + auto enable_console_output(bool enable) -> void { m_console_output = enable; } + auto enable_file_output(bool enable) -> void { m_file_output = enable; } + auto set_log_file(const std::string& filename) -> void; + + auto get_time_stamp() -> std::string; + auto get_log_level_string(LogLevel level) -> std::string; + auto set_console_color(LogLevel level) -> void; + auto reset_console_color() -> void; - std::string get_time_stamp(); - std::string get_log_level_string(LogLevel level); - void set_console_color(LogLevel level); - void reset_console_color(); private: LogLevel m_log_level; bool m_console_output; diff --git a/src/core/memory.h b/src/core/memory.h index cbfbe82..3240c71 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -2,22 +2,22 @@ #include -namespace Donut +namespace Donut { template using Ref = std::shared_ptr; - template + template using Scope = std::unique_ptr; - - template - constexpr Scope create_scope(Args&& ... args) + + template + constexpr auto create_scope(Args&& ... args) -> Scope { return std::make_unique(std::forward(args)...); } - + template - constexpr Ref create_ref(Args&& ... args) + constexpr auto create_ref(Args&& ... args) -> Ref { return std::make_shared(std::forward(args)...); } diff --git a/src/core/settings_manager.cpp b/src/core/settings_manager.cpp index 77f365e..ca4cac5 100644 --- a/src/core/settings_manager.cpp +++ b/src/core/settings_manager.cpp @@ -12,7 +12,7 @@ namespace Donut Settings SettingsManager::s_settings; bool SettingsManager::s_initialized = false; - void SettingsManager::initialize() + auto SettingsManager::initialize() -> void { if (s_initialized) return; @@ -22,7 +22,7 @@ namespace Donut DONUT_INFO("Settings Manager initialized"); } - void SettingsManager::shutdown() + auto SettingsManager::shutdown() -> void { if (!s_initialized) return; @@ -32,7 +32,7 @@ namespace Donut DONUT_INFO("Settings Manager shutdown"); } - void SettingsManager::load_settings() + auto SettingsManager::load_settings() -> void { std::string file_path = get_settings_file_path(); @@ -105,7 +105,7 @@ namespace Donut } } - void SettingsManager::save_settings() + auto SettingsManager::save_settings() -> void { std::string file_path = get_settings_file_path(); @@ -158,24 +158,24 @@ namespace Donut } } - void SettingsManager::set_simulation_settings(const SimulationSettings& settings) + auto SettingsManager::set_simulation_settings(const SimulationSettings& settings) -> void { s_settings.simulation = settings; save_settings(); } - void SettingsManager::set_graphics_settings(const GraphicsSettings& settings) + auto SettingsManager::set_graphics_settings(const GraphicsSettings& settings) -> void { s_settings.graphics = settings; save_settings(); } - std::string SettingsManager::get_settings_file_path() + auto SettingsManager::get_settings_file_path() -> std::string { return "config/settings.toml"; } - void SettingsManager::load_default_settings() + auto SettingsManager::load_default_settings() -> void { s_settings.simulation.target_fps = 60; s_settings.simulation.compute_height = 512; diff --git a/src/core/settings_manager.h b/src/core/settings_manager.h index 44a4bcf..95826c7 100644 --- a/src/core/settings_manager.h +++ b/src/core/settings_manager.h @@ -7,28 +7,28 @@ namespace Donut { struct SimulationSettings { - int target_fps = 60; - int compute_height = 512; + int target_fps = 60; + int compute_height = 512; int max_steps_moving = 30000; int max_steps_static = 15000; float early_exit_distance = 5e12f; - bool gravity_enabled = true; - float disk_thickness = 0.1f; - float disk_density = 0.1f; - float rotation_speed = 1.0f; - float blur_strength = 2.0f; - float glow_intensity = 0.1f; + bool gravity_enabled = true; + float disk_thickness = 0.1f; + float disk_density = 0.1f; + float rotation_speed = 1.0f; + float blur_strength = 2.0f; + float glow_intensity = 0.1f; }; struct GraphicsSettings { - std::string render_api = "OpenGL"; + std::string render_api = "OpenGL"; bool v_sync_enabled = true; - bool show_fps = true; + bool show_fps = true; bool show_performance_metrics = true; bool show_debug_info = false; bool enable_anti_aliasing = true; - std::string selected_theme = "Dark"; + std::string selected_theme = "Dark"; }; struct Settings @@ -40,39 +40,41 @@ namespace Donut class SettingsManager { public: - static void initialize(); - static void shutdown(); - - static void load_settings(); - static void save_settings(); - - static Settings& get_settings() { return s_settings; } - static const Settings& get_settings_const() { return s_settings; } - - static void set_simulation_settings(const SimulationSettings& settings); - static void set_graphics_settings(const GraphicsSettings& settings); + static auto initialize() -> void; + static auto shutdown() -> void; + + static auto load_settings() -> void; + static auto save_settings() -> void; + + static auto get_settings() -> Settings& { return s_settings; } + static auto get_settings_const() -> const Settings& { return s_settings; } + + static auto set_simulation_settings(const SimulationSettings& settings) -> void; + static auto set_graphics_settings(const GraphicsSettings& settings) -> void; + + static auto get_target_fps() -> int { return s_settings.simulation.target_fps; } + static auto get_compute_height() -> int { return s_settings.simulation.compute_height; } + static auto get_max_steps_moving() -> int { return s_settings.simulation.max_steps_moving; } + static auto get_max_steps_static() -> int { return s_settings.simulation.max_steps_static; } + static auto get_early_exit_distance() -> float { return s_settings.simulation.early_exit_distance; } + static auto get_gravity_enabled() -> bool { return s_settings.simulation.gravity_enabled; } + static auto get_disk_thickness() -> float { return s_settings.simulation.disk_thickness; } + static auto get_disk_density() -> float { return s_settings.simulation.disk_density; } + static auto get_rotation_speed() -> float { return s_settings.simulation.rotation_speed; } + static auto get_blur_strength() -> float { return s_settings.simulation.blur_strength; } + static auto get_glow_intensity() -> float { return s_settings.simulation.glow_intensity; } + static auto get_render_api() -> std::string { return s_settings.graphics.render_api; } + static auto get_v_sync_enabled() -> bool { return s_settings.graphics.v_sync_enabled; } + static auto get_show_fps() -> bool { return s_settings.graphics.show_fps; } + static auto get_show_performance_metrics() -> bool { return s_settings.graphics.show_performance_metrics; } + static auto get_show_debug_info() -> bool { return s_settings.graphics.show_debug_info; } + static auto get_enable_anti_aliasing() -> bool { return s_settings.graphics.enable_anti_aliasing; } + static auto get_selected_theme() -> std::string { return s_settings.graphics.selected_theme; } - static int get_target_fps() { return s_settings.simulation.target_fps; } - static int get_compute_height() { return s_settings.simulation.compute_height; } - static int get_max_steps_moving() { return s_settings.simulation.max_steps_moving; } - static int get_max_steps_static() { return s_settings.simulation.max_steps_static; } - static float get_early_exit_distance() { return s_settings.simulation.early_exit_distance; } - static bool get_gravity_enabled() { return s_settings.simulation.gravity_enabled; } - static float get_disk_thickness() { return s_settings.simulation.disk_thickness; } - static float get_disk_density() { return s_settings.simulation.disk_density; } - static float get_rotation_speed() { return s_settings.simulation.rotation_speed; } - static float get_blur_strength() { return s_settings.simulation.blur_strength; } - static float get_glow_intensity() { return s_settings.simulation.glow_intensity; } - static std::string get_render_api() { return s_settings.graphics.render_api; } - static bool get_v_sync_enabled() { return s_settings.graphics.v_sync_enabled; } - static bool get_show_fps() { return s_settings.graphics.show_fps; } - static bool get_show_performance_metrics() { return s_settings.graphics.show_performance_metrics; } - static bool get_show_debug_info() { return s_settings.graphics.show_debug_info; } - static bool get_enable_anti_aliasing() { return s_settings.graphics.enable_anti_aliasing; } - static std::string get_selected_theme() { return s_settings.graphics.selected_theme; } private: - static std::string get_settings_file_path(); - static void load_default_settings(); + static auto get_settings_file_path() -> std::string; + static auto load_default_settings() -> void; + private: static Settings s_settings; static bool s_initialized; diff --git a/src/core/state.h b/src/core/state.h index f4fe9b3..623f1c2 100644 --- a/src/core/state.h +++ b/src/core/state.h @@ -8,12 +8,12 @@ namespace Donut { public: virtual ~State() = default; - - virtual void on_enter() = 0; - virtual void on_exit() = 0; - virtual void on_update(float delta_time) = 0; - virtual void on_render() = 0; - virtual void on_im_ui_render() = 0; - virtual void on_event(Event& event) = 0; + + virtual auto on_enter() -> void = 0; + virtual auto on_exit() -> void = 0; + virtual auto on_update(float delta_time) -> void = 0; + virtual auto on_render() -> void = 0; + virtual auto on_im_ui_render() -> void = 0; + virtual auto on_event(Event& event) -> void = 0; }; }; diff --git a/src/core/state_manager.cpp b/src/core/state_manager.cpp index 5086ddd..8018401 100644 --- a/src/core/state_manager.cpp +++ b/src/core/state_manager.cpp @@ -3,23 +3,23 @@ namespace Donut { - void StateManager::shutdown() + auto StateManager::shutdown() -> void { if (m_current_state) m_current_state->on_exit(); - + destroy_states(); DONUT_INFO("StateManager shutdown"); } - void StateManager::destroy_states() + auto StateManager::destroy_states() -> void { m_states.clear(); m_current_state = nullptr; m_current_state_name = ""; } - void StateManager::register_state(const std::string& state_name, Scope state) + auto StateManager::register_state(const std::string& state_name, Scope state) -> void { if (m_states.find(state_name) != m_states.end()) DONUT_WARN("State '{}' already exists, overwriting", state_name); @@ -27,7 +27,7 @@ namespace Donut DONUT_INFO("Registered state: {}", state_name); } - void StateManager::switch_to_state(const std::string& state_name) + auto StateManager::switch_to_state(const std::string& state_name) -> void { auto it = m_states.find(state_name); if (it == m_states.end()) @@ -49,7 +49,7 @@ namespace Donut DONUT_INFO("Switched to state: {}", state_name); } - State* StateManager::get_state(const std::string& state_name) + auto StateManager::get_state(const std::string& state_name) -> State* { auto it = m_states.find(state_name); if (it != m_states.end()) @@ -57,30 +57,30 @@ namespace Donut return nullptr; } - bool StateManager::has_state(const std::string& state_name) const + auto StateManager::has_state(const std::string& state_name) const -> bool { return m_states.find(state_name) != m_states.end(); } - void StateManager::update(float delta_time) + auto StateManager::update(float delta_time) -> void { if (m_current_state) m_current_state->on_update(delta_time); } - void StateManager::render() + auto StateManager::render() -> void { if (m_current_state) m_current_state->on_render(); } - void StateManager::on_im_ui_render() + auto StateManager::on_im_ui_render() -> void { if (m_current_state) m_current_state->on_im_ui_render(); } - void StateManager::on_event(Event& event) + auto StateManager::on_event(Event& event) -> void { if (m_current_state) m_current_state->on_event(event); diff --git a/src/core/state_manager.h b/src/core/state_manager.h index 584df11..446841e 100644 --- a/src/core/state_manager.h +++ b/src/core/state_manager.h @@ -12,29 +12,30 @@ namespace Donut { public: ~StateManager() = default; - void shutdown(); - - void update(float delta_time); - void render(); - void on_im_ui_render(); - void on_event(Event& event); - - void register_state(const std::string& state_name, Scope state); - void switch_to_state(const std::string& state_name); - - std::string get_current_state_name() const { return m_current_state_name; } - State* get_current_state() const { return m_current_state; } - - State* get_state(const std::string& state_name); - bool has_state(const std::string& state_name) const; + auto shutdown() -> void; + + auto update(float delta_time) -> void; + auto render() -> void; + auto on_im_ui_render() -> void; + auto on_event(Event& event) -> void; + + auto register_state(const std::string& state_name, Scope state) -> void; + auto switch_to_state(const std::string& state_name) -> void; + + auto get_current_state_name() const -> std::string { return m_current_state_name; } + auto get_current_state() const -> State* { return m_current_state; } + + auto get_state(const std::string& state_name) -> State*; + auto has_state(const std::string& state_name) const -> bool; + private: - void create_states(); - void destroy_states(); + auto create_states() -> void; + auto destroy_states() -> void; private: - State* m_current_state = nullptr; + State* m_current_state = nullptr; std::string m_current_state_name = ""; - + std::unordered_map> m_states; }; } diff --git a/src/core/theme_manager.cpp b/src/core/theme_manager.cpp index db48e12..4ae025f 100644 --- a/src/core/theme_manager.cpp +++ b/src/core/theme_manager.cpp @@ -4,7 +4,7 @@ namespace Donut { Theme ThemeManager::s_current_theme = Theme::Dark; - void ThemeManager::set_theme(Theme theme) + auto ThemeManager::set_theme(Theme theme) -> void { s_current_theme = theme; @@ -22,7 +22,7 @@ namespace Donut } } - void ThemeManager::apply_dark_theme() + auto ThemeManager::apply_dark_theme() -> void { ImGuiStyle& style = ImGui::GetStyle(); ImVec4* colors = style.Colors; @@ -111,7 +111,7 @@ namespace Donut style.DisabledAlpha = 0.6f; } - void ThemeManager::apply_light_theme() + auto ThemeManager::apply_light_theme() -> void { ImGuiStyle& style = ImGui::GetStyle(); ImVec4* colors = style.Colors; @@ -200,7 +200,7 @@ namespace Donut style.DisabledAlpha = 0.6f; } - void ThemeManager::apply_blue_theme() + auto ThemeManager::apply_blue_theme() -> void { ImGuiStyle& style = ImGui::GetStyle(); ImVec4* colors = style.Colors; diff --git a/src/core/theme_manager.h b/src/core/theme_manager.h index 7c1a295..d067906 100644 --- a/src/core/theme_manager.h +++ b/src/core/theme_manager.h @@ -14,13 +14,13 @@ namespace Donut class ThemeManager { public: - static void set_theme(Theme theme); - static Theme get_current_theme() { return s_current_theme; } - - static void apply_dark_theme(); - static void apply_light_theme(); - static void apply_blue_theme(); - + static auto set_theme(Theme theme) -> void; + static auto get_current_theme() -> Theme { return s_current_theme; } + + static auto apply_dark_theme() -> void; + static auto apply_light_theme() -> void; + static auto apply_blue_theme() -> void; + private: static Theme s_current_theme; }; diff --git a/src/core/window.cpp b/src/core/window.cpp index 0a9ac8b..619d7e1 100644 --- a/src/core/window.cpp +++ b/src/core/window.cpp @@ -15,7 +15,7 @@ namespace Donut static uint32_t s_glfw_window_count = 0; Window::Window(const std::string& title, int width, int height) - : m_title(title), m_width(width), + : m_title(title), m_width(width), m_height(height), m_is_closed(false) { init(); @@ -26,10 +26,10 @@ namespace Donut shutdown(); } - void Window::init() + auto Window::init() -> void { DONUT_INFO("Initializing window: ", m_title, " (", m_width, "x", m_height, ")"); - + if (!s_glfw_initialized) { int success = glfwInit(); @@ -64,7 +64,7 @@ namespace Donut glfwTerminate(); return; } - + DONUT_INFO("GLFW window created successfully"); if (RendererAPI::get_api() != RendererAPI::API::Vulkan) @@ -85,12 +85,12 @@ namespace Donut s_glfw_window_count++; } - void Window::shutdown() + auto Window::shutdown() -> void { DONUT_INFO("Shutting down window: ", m_title); - + shutdown_im_gui(); - + glfwDestroyWindow(m_window); s_glfw_window_count--; @@ -102,33 +102,33 @@ namespace Donut } } - void Window::on_update() const + auto Window::on_update() const -> void { glfwPollEvents(); if (RendererAPI::get_api() != RendererAPI::API::Vulkan) glfwSwapBuffers(m_window); } - bool Window::should_close() const + auto Window::should_close() const -> bool { return glfwWindowShouldClose(m_window) || m_is_closed; } - void Window::set_cursor_locked(bool locked) + auto Window::set_cursor_locked(bool locked) -> void { m_cursor_locked = locked; - glfwSetInputMode(m_window, GLFW_CURSOR, locked ? + glfwSetInputMode(m_window, GLFW_CURSOR, locked ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL); } - void Window::set_cursor_visible(bool visible) + auto Window::set_cursor_visible(bool visible) -> void { m_cursor_visible = visible; - glfwSetInputMode(m_window, GLFW_CURSOR, visible ? + glfwSetInputMode(m_window, GLFW_CURSOR, visible ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN); } - void Window::init_im_gui() + auto Window::init_im_gui() -> void { IMGUI_CHECKVERSION(); ImGui::CreateContext(); @@ -155,15 +155,15 @@ namespace Donut #else ImGui_ImplOpenGL3_Init("#version 130"); #endif - + DONUT_INFO("ImGUI initialized successfully"); } - void Window::setup_im_gui_fonts() + 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) { @@ -172,36 +172,36 @@ namespace Donut } 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"); } - void Window::shutdown_im_gui() + auto Window::shutdown_im_gui() -> void { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); - + DONUT_INFO("ImGUI shutdown"); } - void Window::begin_im_gui_frame() + auto Window::begin_im_gui_frame() -> void { ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame(); } - void Window::end_im_gui_frame() + auto Window::end_im_gui_frame() -> void { ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); @@ -216,32 +216,32 @@ namespace Donut } } - void Window::glfw_error_callback(int error, const char* description) + auto Window::glfw_error_callback(int error, const char* description) -> void { DONUT_ERROR("GLFW Error ({}): {}", error, description ? description : ""); } - void Window::glfw_window_close_callback(GLFWwindow* window) + auto Window::glfw_window_close_callback(GLFWwindow* window) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); WindowCloseEvent event; win->m_event_handler.on_event(event); } - void Window::glfw_window_size_callback(GLFWwindow* window, int width, int height) + auto Window::glfw_window_size_callback(GLFWwindow* window, int width, int height) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); win->m_width = width; win->m_height = height; - + WindowResizeEvent event(width, height); win->m_event_handler.on_event(event); } - void Window::glfw_window_focus_callback(GLFWwindow* window, int focused) + auto Window::glfw_window_focus_callback(GLFWwindow* window, int focused) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); - + if (focused) { WindowFocusEvent event; @@ -254,18 +254,18 @@ namespace Donut } } - void Window::glfw_window_pos_callback(GLFWwindow* window, int xpos, int ypos) + auto Window::glfw_window_pos_callback(GLFWwindow* window, int xpos, int ypos) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); WindowMovedEvent event(xpos, ypos); win->m_event_handler.on_event(event); } - void Window::glfw_key_callback(GLFWwindow* window, int key, int scancode, - int action, int mods) + auto Window::glfw_key_callback(GLFWwindow* window, int key, int scancode, + int action, int mods) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); - + switch (action) { case GLFW_PRESS: @@ -286,18 +286,18 @@ namespace Donut } } - void Window::glfw_char_callback(GLFWwindow* window, unsigned int keycode) + auto Window::glfw_char_callback(GLFWwindow* window, unsigned int keycode) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); KeyTypedEvent event(keycode); win->m_event_handler.on_event(event); } - void Window::glfw_mouse_button_callback(GLFWwindow* window, int button, - int action, int mods) + auto Window::glfw_mouse_button_callback(GLFWwindow* window, int button, + int action, int mods) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); - + switch (action) { case GLFW_PRESS: @@ -313,14 +313,14 @@ namespace Donut } } - void Window::glfw_mouse_scroll_callback(GLFWwindow* window, double x_offset, double y_offset) + auto Window::glfw_mouse_scroll_callback(GLFWwindow* window, double x_offset, double y_offset) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); MouseScrolledEvent event((float)x_offset, (float)y_offset); win->m_event_handler.on_event(event); } - void Window::glfw_cursor_pos_callback(GLFWwindow* window, double x_pos, double y_pos) + auto Window::glfw_cursor_pos_callback(GLFWwindow* window, double x_pos, double y_pos) -> void { Window* win = static_cast(glfwGetWindowUserPointer(window)); MouseMovedEvent event((float)x_pos, (float)y_pos); diff --git a/src/core/window.h b/src/core/window.h index 92842ba..9b7d7b9 100644 --- a/src/core/window.h +++ b/src/core/window.h @@ -18,46 +18,48 @@ namespace Donut Window(const std::string& title, int width, int height); ~Window(); - bool should_close() const; - void on_update() const; + auto should_close() const -> bool; + auto on_update() const -> void; - void set_event_callback(const EventCallbackFn& callback) + auto set_event_callback(const EventCallbackFn& callback) -> void { m_event_handler.set_event_callback(callback); } - EventHandler& get_event_handler() { return m_event_handler; } + auto get_event_handler() -> EventHandler& { return m_event_handler; } - unsigned int get_width() const { return m_width; } - unsigned int get_height() const { return m_height; } + auto get_width() const -> unsigned int { return m_width; } + auto get_height() const -> unsigned int { return m_height; } - void* get_native_window() const { return m_window; } + auto get_native_window() const -> void* { return m_window; } + + auto set_cursor_locked(bool locked) -> void; + auto set_cursor_visible(bool visible) -> void; + 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; - void set_cursor_locked(bool locked); - void set_cursor_visible(bool visible); - bool is_cursor_locked() const { return m_cursor_locked; } - bool is_cursor_visible() const { return m_cursor_visible; } - - void init_im_gui(); - void begin_im_gui_frame(); - void end_im_gui_frame(); private: - void init(); - void shutdown(); - - void setup_im_gui_fonts(); - void shutdown_im_gui(); - - static void glfw_error_callback(int error, const char* description); - static void glfw_window_close_callback(GLFWwindow* window); - static void glfw_window_size_callback(GLFWwindow* window, int width, int height); - static void glfw_window_focus_callback(GLFWwindow* window, int focused); - static void glfw_window_pos_callback(GLFWwindow* window, int xpos, int ypos); - static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods); - static void glfw_char_callback(GLFWwindow* window, unsigned int keycode); - static void glfw_mouse_button_callback(GLFWwindow* window, int button, int action, int mods); - static void glfw_mouse_scroll_callback(GLFWwindow* window, double x_offset, double y_offset); - static void glfw_cursor_pos_callback(GLFWwindow* window, double x_pos, double y_pos); + 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; + static auto glfw_window_focus_callback(GLFWwindow* window, int focused) -> void; + static auto glfw_window_pos_callback(GLFWwindow* window, int xpos, int ypos) -> void; + static auto glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) -> void; + static auto glfw_char_callback(GLFWwindow* window, unsigned int keycode) -> void; + static auto glfw_mouse_button_callback(GLFWwindow* window, int button, int action, int mods) -> void; + static auto glfw_mouse_scroll_callback(GLFWwindow* window, double x_offset, double y_offset) -> void; + static auto glfw_cursor_pos_callback(GLFWwindow* window, double x_pos, double y_pos) -> void; + private: GLFWwindow* m_window; EventHandler m_event_handler; @@ -68,7 +70,7 @@ 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