camera.hpp

/*
 * MIT License
 *
 * Copyright (c) 2024 Giovanni Santini
 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */
 
#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
 
namespace enums
{
 
enum camera_type
{
    AIRCRAFT,
    SPHERICAL
};
 
enum projection_type
{
    PERSPECTIVE,
    ORTHOGRAPHIC
};
 
enum camera_movement
{
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT
};
 
} // namespace enums
 
class camera
{
  public:
    enums::projection_type projection_type;
    enums::camera_type camera_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;
 
    /* Constructors */
 
    camera() = default;
    camera(enums::camera_type camera_type,
           enums::projection_type projection_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 builder;
 
    /* Getters */
 
    enums::camera_type get_camera_type();
    enums::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();
    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(enums::camera_type camera_type);
    void set_projection_type(enums::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();
};
 
class camera::builder
{
  private:
    enums::camera_type camera_type = enums::camera_type::AIRCRAFT;
    enums::projection_type projection_type =
        enums::projection_type::PERSPECTIVE;
    glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f);
    glm::vec3 world_up = glm::vec3(0.0f, 1.0f, 0.0f);
    glm::vec3 center = glm::vec3(0.0f, 0.0f, 0.0f);
    float movement_speed = 2.5f;
    float mouse_sensitivity = 0.1f;
    float zoom = 45.0f;
    glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f);
    glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
    glm::vec3 right = glm::vec3(1.0f, 0.0f, 0.0f);
    types::spherical_coordinates spherical_coordinates = {0.0f, 0.0f, 10.0f};
    types::euler_angles euler_angles = {0.0f, 0.0f, 0.0f};
 
  public:
    builder &set_camera_type(enums::camera_type camera_type);
    builder &set_projection_type(enums::projection_type projection_type);
    builder &set_position(glm::vec3 position);
    builder &set_world_up(glm::vec3 worldUp);
    builder &set_center(glm::vec3 center);
    builder &set_movement_speed(float movement_speed);
    builder &set_mouse_sensitivity(float mouse_sensitivity);
    builder &set_zoom(float zoom);
    builder &set_spherical_coordinates(
        types::spherical_coordinates spherical_coordinates);
    builder &set_euler_angles(types::euler_angles euler_angles);
    builder &set_front(glm::vec3 front);
    builder &set_up(glm::vec3 up);
    builder &set_right(glm::vec3 right);
 
    camera build();
};
 
extern camera default_camera;
 
} // namespace brenta