feat: I am going to throw my computer out a window

2 files changed, 209 insertions, 38 deletions

diff --git a/src/core/camera.cpp b/src/core/camera.cpp
index f580191..43cb1ee 100644
--- a/src/core/camera.cpp
+++ b/src/core/camera.cpp
@@ -28,22 +28,32 @@ namespace Donut
 
     void Camera::recalculate_view_matrix()
     {
-        float pitch = glm::radians(m_rotation.x);
-        float yaw   = glm::radians(m_rotation.y);
-        float roll  = glm::radians(m_rotation.z);
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            float pitch = glm::radians(m_rotation.x);
+            float yaw   = glm::radians(m_rotation.y);
+            float roll  = glm::radians(m_rotation.z);
 
-        glm::vec3 direction;
-        direction.x = cos(yaw) * cos(pitch);
-        direction.y = sin(pitch);
-        direction.z = sin(yaw) * cos(pitch);
+            glm::vec3 direction;
+            direction.x = cos(yaw) * cos(pitch);
+            direction.y = sin(pitch);
+            direction.z = sin(yaw) * cos(pitch);
 
-        glm::vec3 world_up(0.0f, 1.0f, 0.0f);
-        glm::vec3 front = glm::normalize(direction);
-        glm::vec3 right = glm::normalize(glm::cross(front, world_up));
-        glm::vec3 up    = glm::normalize(glm::cross(right, front));
+            glm::vec3 world_up(0.0f, 1.0f, 0.0f);
+            glm::vec3 front = glm::normalize(direction);
+            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_projection_matrix = m_projection_matrix * m_view_matrix;
+            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)
+        {
+            glm::vec3 position = get_orbital_position();
+            glm::vec3 world_up(0.0f, 1.0f, 0.0f);
+            m_view_matrix = glm::lookAt(position, m_target, world_up);
+            m_view_projection_matrix = m_projection_matrix * m_view_matrix;
+        }
     }
 
     glm::vec3 Camera::get_forward_direction() const
@@ -72,58 +82,152 @@ namespace Donut
 
     void Camera::on_mouse_move(float x_offset, float y_offset, bool constrain_pitch)
     {
-        x_offset *= m_mouse_sensitivity;
-        y_offset *= m_mouse_sensitivity;
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            x_offset *= m_mouse_sensitivity;
+            y_offset *= m_mouse_sensitivity;
 
-        m_rotation.y += x_offset;
-        m_rotation.x += y_offset;
+            m_rotation.y += x_offset;
+            m_rotation.x += y_offset;
 
-        if (constrain_pitch)
-        {
-            if (m_rotation.x > 89.0f)
-                m_rotation.x = 89.0f;
-            if (m_rotation.x < -89.0f)
-                m_rotation.x = -89.0f;
-        }
+            if (constrain_pitch)
+            {
+                if (m_rotation.x > 89.0f)
+                    m_rotation.x = 89.0f;
+                if (m_rotation.x < -89.0f)
+                    m_rotation.x = -89.0f;
+            }
 
-        recalculate_view_matrix();
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_forward(float delta_time)
     {
-        m_position += get_forward_direction() * m_movement_speed * delta_time;
-        recalculate_view_matrix();
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            m_position += get_forward_direction() * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_backward(float delta_time)
     {
-        m_position -= get_forward_direction() * m_movement_speed * delta_time;
-        recalculate_view_matrix();
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            m_position -= get_forward_direction() * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_right(float delta_time)
     {
-        m_position += get_right_direction() * m_movement_speed * delta_time;
-        recalculate_view_matrix();
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            m_position += get_right_direction() * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_left(float delta_time)
     {
-        m_position -= get_right_direction() * m_movement_speed * delta_time;
-        recalculate_view_matrix();
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            m_position -= get_right_direction() * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_up(float delta_time)
     {
-        glm::vec3 world_up(0.0f, 1.0f, 0.0f);
-        m_position += world_up * m_movement_speed * delta_time;
-        recalculate_view_matrix();
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            glm::vec3 world_up(0.0f, 1.0f, 0.0f);
+            m_position += world_up * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
     }
 
     void Camera::move_down(float delta_time)
     {
-        glm::vec3 world_up(0.0f, 1.0f, 0.0f);
-        m_position -= world_up * m_movement_speed * delta_time;
+        if (m_camera_mode == CameraMode::FPS)
+        {
+            glm::vec3 world_up(0.0f, 1.0f, 0.0f);
+            m_position -= world_up * m_movement_speed * delta_time;
+            recalculate_view_matrix();
+        }
+    }
+
+    void Camera::set_orbital_mode(bool enabled)
+    {
+        m_camera_mode = enabled ? CameraMode::Orbital : CameraMode::FPS;
+        recalculate_view_matrix();
+    }
+
+    glm::vec3 Camera::get_orbital_position() const
+    {
+        float clamped_elevation = glm::clamp(m_elevation, 0.01f, float(M_PI) - 0.01f);
+        return glm::vec3(
+            m_radius * sin(clamped_elevation) * cos(m_azimuth),
+            m_radius * cos(clamped_elevation),
+            m_radius * sin(clamped_elevation) * sin(m_azimuth)
+        );
+    }
+
+    void Camera::process_orbital_mouse_move(double x, double y)
+    {
+        if (m_dragging && !m_panning) 
+        {
+            float dx = float(x - m_orbital_last_x);
+            float dy = float(y - m_orbital_last_y);
+            
+            m_azimuth += dx * m_orbit_speed;
+            m_elevation -= dy * m_orbit_speed;
+            m_elevation = glm::clamp(m_elevation, 0.01f, float(M_PI) - 0.01f);
+        }
+        
+        m_orbital_last_x = x;
+        m_orbital_last_y = y;
+        update_orbital_state();
         recalculate_view_matrix();
     }
+
+    void Camera::process_orbital_mouse_button(int button, int action, int mods)
+    {
+        if (button == GLFW_MOUSE_BUTTON_LEFT) 
+        {
+            if (action == GLFW_PRESS) 
+            {
+                m_dragging = true;
+                m_panning = false;
+            } 
+            else if (action == GLFW_RELEASE) 
+            {
+                m_dragging = false;
+                m_panning = false;
+            }
+        }
+        update_orbital_state();
+    }
+
+    void Camera::process_orbital_scroll(double x_offset, double y_offset)
+    {
+        m_radius -= y_offset * m_zoom_speed;
+        m_radius = glm::clamp(m_radius, m_min_radius, m_max_radius);
+        update_orbital_state();
+        recalculate_view_matrix();
+    }
+
+    void Camera::update_orbital_state()
+    {
+        m_target = glm::vec3(0.0f, 0.0f, 0.0f);
+        if (m_dragging || m_panning) 
+        {
+            m_moving = true;
+        } 
+        else 
+        {
+            m_moving = false;
+        }
+    }
 }
diff --git a/src/core/camera.h b/src/core/camera.h
index 25f7e2a..7ea5472 100644
--- a/src/core/camera.h
+++ b/src/core/camera.h
@@ -2,9 +2,21 @@
 
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+#include <GLFW/glfw3.h>
+
+#define _USE_MATH_DEFINES
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 namespace Donut
 {
+    enum class CameraMode
+    {
+        FPS,
+        Orbital
+    };
+
     class Camera
     {
     public:
@@ -42,10 +54,51 @@ namespace Donut
         void set_movement_speed(float speed) { m_movement_speed = speed;   }
         float get_movement_speed()    const  { return m_movement_speed;    }
 
+        void set_orbital_mode(bool enabled);
+        bool is_orbital_mode() const { return m_camera_mode == CameraMode::Orbital; }
+        
+        void set_target(const glm::vec3& target) { m_target = target; }
+        const glm::vec3& get_target() const { return m_target; }
+        
+        void set_radius(double radius) { m_radius = radius; }
+        double get_radius() const { return m_radius; }
+        
+        void set_min_radius(double min_radius) { m_min_radius = min_radius; }
+        double get_min_radius() const { return m_min_radius; }
+        
+        void set_max_radius(double max_radius) { m_max_radius = max_radius; }
+        double get_max_radius() const { return m_max_radius; }
+        
+        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; }
+        
+        void set_orbit_speed(float orbit_speed) { m_orbit_speed = orbit_speed; }
+        float get_orbit_speed() const { return m_orbit_speed; }
+        
+        void set_zoom_speed(double zoom_speed) { m_zoom_speed = zoom_speed; }
+        double get_zoom_speed() const { return m_zoom_speed; }
+        
+        glm::vec3 get_orbital_position() const;
+        
+        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);
+        
+        bool is_dragging() const { return m_dragging; }
+        bool is_panning() const { return m_panning; }
+        bool is_moving() const { return m_moving; }
+
     private:
         void recalculate_view_matrix();
         void recalculate_projection_matrix();
+        void update_orbital_state();
+
     private:
+        CameraMode m_camera_mode = CameraMode::FPS;
+
         glm::mat4 m_projection_matrix;
         glm::mat4 m_view_matrix;
         glm::mat4 m_view_projection_matrix;
@@ -63,5 +116,19 @@ namespace Donut
         bool  m_first_mouse       = true;
         float m_last_x            = 0.0f;
         float m_last_y            = 0.0f;
+
+        glm::vec3 m_target = glm::vec3(0.0f, 0.0f, 0.0f);
+        double m_radius = 6.34194e10;
+        double m_min_radius = 1e10;
+        double m_max_radius = 1e12;
+        float m_azimuth = 0.0f;
+        float m_elevation = static_cast<float>(M_PI) / 2.0f;
+        float m_orbit_speed = 0.01f;
+        double m_zoom_speed = 25e9f;
+        bool m_dragging = false;
+        bool m_panning = false;
+        bool m_moving = false;
+        double m_orbital_last_x = 0.0;
+        double m_orbital_last_y = 0.0;
     };
 }