CameraEntities.hpp

#pragma once
#ifndef KJY_ANIM_ENGINE_CAMERAS_HPP_
#define KJY_ANIM_ENGINE_CAMERAS_HPP_

#include "components/inheritable/camera.hpp"
#include "components/attachable/Pose.hpp"
#include "EntitiesBase.hpp"
#include "util/common.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

using namespace glm;
#define ENABLE_WORLD_GLFW_UTILITIES
#ifdef ENABLE_WORLD_GLFW_UTILITIES
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#endif

#pragma warning(disable: 4250) // Disable warnings about dominance in MSVC

class BaseCameraEntity : virtual public CameraInterface, virtual public PoseableWorldEntity, virtual public CachedFinalPose
{
public:
    BaseCameraEntity() : fov(45.0f), near_plane(.01f), far_plane(100.0f), pose(glm::vec3(0.0f)) {}
    BaseCameraEntity(float fov, const glm::vec3 &loc) : fov(fov), near_plane(.01f), far_plane(100.0f), pose(loc){}
    BaseCameraEntity(float fov, const glm::vec3 &loc, float near_plane, float far_plane) : fov(fov), near_plane(near_plane), far_plane(far_plane), pose(loc){}

    virtual glm::vec3 getLocation() const override{
        return(pose.getCenterOfSpace());
    }

    virtual const Pose& getPose() const override {return(pose);}
    
    virtual void setPose(const Pose& pose) override {this->pose = pose;}

    virtual glm::mat4 getPerspective(float aspect) const override{
        return(glm::perspective(glm::radians(fov), aspect, near_plane, far_plane));
    }

    virtual glm::mat4 getOrthographic() const override{
        return(glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, near_plane, far_plane));
    }

    glm::mat4 getOrthographic(float left, float right, float bottom, float top, float near_plane, float far_plane){
        return(glm::ortho(left, right, bottom, top, near_plane, far_plane));
    }

    virtual glm::mat4 getView() const override;
    virtual glm::vec3 getViewDir() const override;
    virtual glm::vec3 getViewDir(const Pose& aPoseOverride) const override;
    virtual glm::mat4 getView(const Pose& aPoseOverride) const override;
    
    virtual void setNearPlane(float near_plane){this->near_plane = near_plane;}
    virtual void setFarPlane(float far_plane){this->far_plane = far_plane;}

    float fov;
    float near_plane;
    float far_plane;

    Pose pose;
};

class LookAtCamera : public BaseCameraEntity {
public:
    LookAtCamera() : BaseCameraEntity() {}
    LookAtCamera(float fov, const glm::vec3 &loc) : BaseCameraEntity(fov, loc) {}
    LookAtCamera(float fov, const glm::vec3 &loc, float near_plane, float far_plane) : BaseCameraEntity(fov, loc, near_plane, far_plane) {}
    LookAtCamera(float fov, const glm::vec3 &loc, float near_plane, float far_plane, const glm::vec3& lookat) : BaseCameraEntity(fov, loc, near_plane, far_plane), lookat(lookat) {}

    virtual glm::mat4 getView() const override;
    virtual glm::vec3 getViewDir() const override;


    glm::vec3 lookat = vec3(0.0);
    glm::vec3 updir = vec3(0.0, 1.0, 0.0);
};

class FreeLookCamera : public BaseCameraEntity {
public:
    FreeLookCamera() : BaseCameraEntity() {}
    FreeLookCamera(float fov, const glm::vec3 &loc) : BaseCameraEntity(fov, loc) {}
    FreeLookCamera(float fov, const glm::vec3 &loc, float near_plane, float far_plane) : BaseCameraEntity(fov, loc, near_plane, far_plane) {}

    class NavigationParameters {
     public:
        void updateLookWithMouse(const glm::dvec2& mouse, double width, double height);

        inline void resetFactors() {
            forward_factor = right_strafe_factor = elevate_factor = 0.0;
        }

        double mouse_sensitivity = 1.0;
        double forward_factor = 0.0;
        double right_strafe_factor = 0.0;
        double elevate_factor = 0.0;
        glm::dvec2 look_factor = glm::dvec2(0.0,0.0);

     private:
        glm::dvec2 lastmouse = glm::dvec2(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN());
    };

    virtual glm::mat4 getView() const override;
    virtual glm::vec3 getViewDir() const override;
    virtual glm::vec3 getViewDir(const Pose& aPoseOverride) const override;
    virtual glm::mat4 getView(const Pose& aPoseOverride) const override;

    virtual double getSpeed() const {return(speed);}
    virtual double getBoostedSpeed() const {return(boosted_speed);}
    virtual void setSpeed(double speed) {this->speed = speed;}
    virtual void setBoostedSpeed(double speed) {boosted_speed = speed;}

    virtual void driveCamera(const NavigationParameters& parameters);

#ifdef ENABLE_WORLD_GLFW_UTILITIES
    virtual void collectAndDrive(GLFWwindow* window);
    static void collect_camera_controls(GLFWwindow* window, NavigationParameters& params, double speed = 2.0, double boosted_speed = 8.0, double crawl_speed = 0.5);
#endif

protected:
    double azimuth = 0.0; 
    double angle = 0.0;
    double speed = 2.0;
    double boosted_speed = 8.0;
    double crawl_speed = 0.5;
    glm::vec3 updir = vec3(0.0, 1.0, 0.0);
};


class FollowCamera : public BaseCameraEntity{
 public:
    FollowCamera() : BaseCameraEntity() {}
    FollowCamera(float fov, vec3 start_pos, float linear_acceleration_factor = 3.0f, float base_velocity_factor = .6f, float follow_distance = 2.0f, float distance_exponent = 2.0f) 
        : BaseCameraEntity(fov, start_pos), linear_acceleration_factor(linear_acceleration_factor), base_velocity_factor(base_velocity_factor), follow_distance(follow_distance), distance_exponent(distance_exponent) {}


    virtual void follow_explicit(
        double frametime, vec3 target, vec3 offset, vec3 viewtarget,
        float linear_acceleration_parameter, float base_velocity_parameter,
        float follow_distance_parameter, float distance_exponent_parameter
    );
    virtual void follow(double frametime, vec3 target, vec3 offset, vec3 viewtarget);
    virtual void reset(const vec3& start_pos);
    virtual glm::mat4 getView() const {return(look);}
    virtual vec3 getViewDir() const{return(vec3(look*vec4(0.0,0.0,1.0,1.0)));}

    float getMaximumDistance() const {return(max_distance);}
    void setMaximumDistance(float max_distance) {this->max_distance = max_distance;}
    float getAccelerationFactor() {return(linear_acceleration_factor);}
    void setAccelerationFactor(float linear_acceleration_factor) {this->linear_acceleration_factor = linear_acceleration_factor;}
    float getFollowLength() {return(follow_distance);}
    void setFollowLength(float follow_distance) {follow_distance = follow_distance;}

 protected:
    vec3 velocity = vec3(0.0);
    float linear_acceleration_factor = 3.0f;
    float base_velocity_factor = .1f;
    float follow_distance = 2.0f;
    float distance_exponent = 2.5f;
    float max_distance = 500.0f;

    mat4 look;
};

#endif