hachem.wtf
aboutsummaryrefslogtreecommitdiff
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/camera.cpp180
-rw-r--r--src/core/camera.h67
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;
};
}
<im@hachem.wtf>