camera.hpp

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
 
namespace brenta
{
 
namespace types
{
 
struct spherical_coordinates
{
  float theta;
  float phi;
  float radius;
  spherical_coordinates() = default;
  spherical_coordinates(float theta, float phi, float radius)
      : theta(theta), phi(phi), radius(radius)
  {
  }
};
 
struct euler_angles
{
  float yaw;
  float pitch;
  float roll;
  euler_angles() = default;
  euler_angles(float yaw, float pitch, float roll)
      : yaw(yaw), pitch(pitch), roll(roll)
  {
  }
};
 
} // namespace types
 
class camera
{
public:
  
  enum class camera_type
  {
    aircraft,
    spherical
  };
 
  enum class projection_type
  {
    perspective,
    orthographic
  };
 
  enum class camera_movement
  {
    forward,
    backward,
    left,
    right
  };
  
  projection_type proj_type;
  camera_type cam_type;
  glm::vec3 position;
  glm::vec3 world_up;
  glm::vec3 center;
  float movement_speed;
  float mouse_sensitivity;
  float zoom;
  types::spherical_coordinates spherical_coordinates;
  types::euler_angles euler_angles;
  glm::vec3 front;
  glm::vec3 up;
  glm::vec3 right;
  bool first_mouse = true;
  float last_x;
  float last_y;
 
  class config;
  
  // Constructors
 
  camera() = default;
  camera(config conf);
 
  class builder;
 
  // Getters
 
  camera::camera_type get_camera_type();
  camera::projection_type get_projection_type();
  glm::vec3 get_position();
  glm::vec3 get_world_up();
  glm::vec3 get_center();
  float get_movement_speed();
  float get_mouse_sensitivity();
  float get_zoom();
  types::spherical_coordinates get_spherical_coordinates();
  types::euler_angles get_euler_angles();
  glm::mat4 get_view_matrix();
  glm::mat4 get_projection_matrix(int window_width, int window_height);
  glm::vec3 get_front();
  glm::vec3 get_up();
  glm::vec3 get_right();
  bool get_first_mouse();
  float get_last_x();
  float get_last_y();
 
  // Setters
 
  void set_camera_type(camera::camera_type camera_type);
  void set_projection_type(camera::projection_type projection_type);
  void set_world_up(glm::vec3 world_up);
  void set_center(glm::vec3 center);
  void set_movement_speed(float movement_speed);
  void set_mouse_sensitivity(float mouse_sensitivity);
  void set_zoom(float zoom);
  void
  set_spherical_coordinates(types::spherical_coordinates spherical_coordinates);
  void set_euler_angles(types::euler_angles euler_angles);
  void set_front(glm::vec3 front);
  void set_up(glm::vec3 up);
  void set_right(glm::vec3 right);
  void set_position(glm::vec3 position);
  void set_first_mouse(bool first_mouse);
  void set_last_x(float last_x);
  void set_last_y(float last_y);
 
  // Utilities
 
  void update_camera_euler();
  void spherical_to_cartesian();
};
 
struct camera::config
{
  camera_type cam_type;
  projection_type proj_type;
  glm::vec3 position;
  glm::vec3 world_up;
  glm::vec3 center;
  float movement_speed;
  float mouse_sensitivity;
  float zoom;
  types::spherical_coordinates spherical_coordinates;
  types::euler_angles euler_angles;
  glm::vec3 front;
  glm::vec3 up;
  glm::vec3 right;
};
  
class camera::builder
{
private:
 
  camera::config conf = {
    camera::camera_type::aircraft,
    camera::projection_type::perspective,
    glm::vec3(0.0f, 0.0f, 0.0f),
    glm::vec3(0.0f, 1.0f, 0.0f),
    glm::vec3(0.0f, 0.0f, 0.0f),
    2.5f,
    0.1f,
    45.0f,
    {0.0f, 0.0f, 10.0f},
    {0.0f, 0.0f, 0.0f},
    glm::vec3(0.0f, 0.0f, -1.0f),
    glm::vec3(0.0f, 1.0f, 0.0f),
    glm::vec3(1.0f, 0.0f, 0.0f),
  };
 
public:
  
  builder &camera_type(camera::camera_type camera_type);
  builder &projection_type(camera::projection_type projection_type);
  builder &position(glm::vec3 position);
  builder &world_up(glm::vec3 worldUp);
  builder &center(glm::vec3 center);
  builder &movement_speed(float movement_speed);
  builder &mouse_sensitivity(float mouse_sensitivity);
  builder &zoom(float zoom);
  builder &
  spherical_coordinates(types::spherical_coordinates spherical_coordinates);
  builder &euler_angles(types::euler_angles euler_angles);
  builder &front(glm::vec3 front);
  builder &up(glm::vec3 up);
  builder &right(glm::vec3 right);
 
  camera build();
};
 
} // namespace brenta