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
{
 
enum CameraMovement
{
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT
};
 
struct SphericalCoordinates
{
    float theta;
    float phi;
    float radius;
};
 
struct EulerAngles
{
    float yaw;
    float pitch;
    float roll;
};
 
} // namespace Types
 
namespace Enums
{
 
enum CameraType
{
    AIRCRAFT,
    SPHERICAL
};
 
enum ProjectionType
{
    PERSPECTIVE,
    ORTHOGRAPHIC
};
 
} // namespace Enums
 
class Camera
{
  public:
    Enums::ProjectionType ProjectionType;
    Enums::CameraType CameraType;
    glm::vec3 Position;
    glm::vec3 WorldUp;
    glm::vec3 center;
    float MovementSpeed;
    float MouseSensitivity;
    float Zoom;
    Types::SphericalCoordinates sphericalCoordinates;
    Types::EulerAngles eulerAngles;
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    bool firstMouse = true;
    float lastX;
    float lastY;
 
    /* Constructors */
 
    Camera() = default;
    Camera(Enums::CameraType camera_type, Enums::ProjectionType projection_type,
           glm::vec3 position, glm::vec3 worldUp, glm::vec3 center,
           float movementSpeed, float mouseSensitivity, float zoom,
           Types::SphericalCoordinates sphericalCoordinates,
           Types::EulerAngles eulerAngles, glm::vec3 front, glm::vec3 up,
           glm::vec3 right);
 
    class Builder;
 
    /* Getters */
 
    Enums::CameraType GetCameraType();
    Enums::ProjectionType GetProjectionType();
    glm::vec3 GetPosition();
    glm::vec3 GetWorldUp();
    glm::vec3 GetCenter();
    float GetMovementSpeed();
    float GetMouseSensitivity();
    float GetZoom();
    Types::SphericalCoordinates GetSphericalCoordinates();
    Types::EulerAngles GetEulerAngles();
    glm::mat4 GetViewMatrix();
    glm::mat4 GetProjectionMatrix();
    glm::vec3 GetFront();
    glm::vec3 GetUp();
    glm::vec3 GetRight();
    bool GetFirstMouse();
    float GetLastX();
    float GetLastY();
 
    /* Setters */
 
    void SetCameraType(Enums::CameraType camera_type);
    void SetProjectionType(Enums::ProjectionType projection_type);
    void SetWorldUp(glm::vec3 worldUp);
    void SetCenter(glm::vec3 center);
    void SetMovementSpeed(float movementSpeed);
    void SetMouseSensitivity(float mouseSensitivity);
    void SetZoom(float zoom);
    void
    SetSphericalCoordinates(Types::SphericalCoordinates sphericalCoordinates);
    void SetEulerAngles(Types::EulerAngles eulerAngles);
    void SetFront(glm::vec3 front);
    void SetUp(glm::vec3 up);
    void SetRight(glm::vec3 right);
    void SetPosition(glm::vec3 position);
    void SetFirstMouse(bool firstMouse);
    void SetLastX(float lastX);
    void SetLastY(float lastY);
 
    /* Utilities */
 
    void updateCameraEuler();
    void SphericalToCartesian();
};
 
class Camera::Builder
{
  private:
    Enums::CameraType camera_type = Enums::CameraType::AIRCRAFT;
    Enums::ProjectionType projection_type = Enums::ProjectionType::PERSPECTIVE;
    glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f);
    glm::vec3 worldUp = glm::vec3(0.0f, 1.0f, 0.0f);
    glm::vec3 center = glm::vec3(0.0f, 0.0f, 0.0f);
    float movementSpeed = 2.5f;
    float mouseSensitivity = 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::SphericalCoordinates sphericalCoordinates = {0.0f, 0.0f, 10.0f};
    Types::EulerAngles eulerAngles = {0.0f, 0.0f, 0.0f};
 
  public:
    Builder &set_camera_type(Enums::CameraType camera_type);
    Builder &set_projection_type(Enums::ProjectionType 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 movementSpeed);
    Builder &set_mouse_sensitivity(float mouseSensitivity);
    Builder &set_zoom(float zoom);
    Builder &
    set_spherical_coordinates(Types::SphericalCoordinates sphericalCoordinates);
    Builder &set_eulerAngles(Types::EulerAngles eulerAngles);
    Builder &set_front(glm::vec3 front);
    Builder &set_up(glm::vec3 up);
    Builder &set_right(glm::vec3 right);
 
    Camera build();
};
 
extern Camera camera;
 
} // namespace Brenta