Camera.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_CAMERA_HPP
#define CSCI441_CAMERA_HPP
 
#include "constants.h"
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/gtc/matrix_transform.hpp>
 
namespace CSCI441 {
 
    class Camera {
    public:
        virtual ~Camera() = default;
 
        virtual void recomputeOrientation() = 0;
 
        [[maybe_unused]] virtual void moveForward(GLfloat movementFactor) = 0;
 
        [[maybe_unused]] virtual void moveBackward(GLfloat movementFactor) = 0;
 
        [[maybe_unused]] [[maybe_unused]] virtual void rotate(GLfloat dTheta, GLfloat dPhi);
 
        virtual void computeViewMatrix() final { mViewMatrix = glm::lookAt(mCameraPosition, mCameraLookAtPoint, mCameraUpVector ); }
 
         [[maybe_unused]] [[nodiscard]] virtual glm::mat4 getProjectionMatrix() const final { return mProjectionMatrix; }
        [[maybe_unused]] [[nodiscard]] virtual glm::mat4 getViewMatrix() const final { return mViewMatrix; }
        [[nodiscard]] virtual glm::vec3 getPosition() const final { return mCameraPosition; }
        [[nodiscard]] virtual glm::vec3 getLookAtPoint() const final { return mCameraLookAtPoint; }
        [[nodiscard]] virtual glm::vec3 getUpVector() const final { return glm::normalize(mCameraUpVector); }
        [[nodiscard]] virtual GLfloat getTheta() const final { return mCameraTheta; }
        [[nodiscard]] virtual GLfloat getPhi() const final { return mCameraPhi; }
        [[maybe_unused]] [[nodiscard]] virtual GLfloat getRadius() const final { return mCameraRadius; }
        [[maybe_unused]] [[nodiscard]] virtual glm::vec3 getViewDirection() const final { return glm::normalize(mCameraDirection); }
 
        virtual void setPosition( const glm::vec3 pos ) final { mCameraPosition = pos; }
        virtual void setLookAtPoint( const glm::vec3 lookAt ) final { mCameraLookAtPoint = lookAt; }
        virtual void setUpVector( const glm::vec3 up ) final { mCameraUpVector = up; }
        virtual void setTheta( const GLfloat t ) final { mCameraTheta = t; }
        virtual void setPhi( const GLfloat p ) final { mCameraPhi = p; }
        virtual void setRadius( const GLfloat r ) final { mCameraRadius = r; }
 
    protected:
        Camera();
 
        Camera(const Camera&) = default;
        Camera& operator=(const Camera&) = default;
 
        Camera(Camera&&) = default;
        Camera& operator=(Camera&&) = default;
 
        glm::mat4 mProjectionMatrix;
 
        glm::mat4 mViewMatrix;
 
        glm::vec3 mCameraPosition;
        glm::vec3 mCameraDirection;
        glm::vec3 mCameraLookAtPoint;
        glm::vec3 mCameraUpVector;
 
        GLfloat mCameraTheta;
        GLfloat mCameraPhi;
        GLfloat mCameraRadius;
 
    private:
        void _clampCameraPhi();
    };
}
 
inline CSCI441::Camera::Camera() :
        mProjectionMatrix( glm::mat4(1.0f) ),
        mViewMatrix( glm::mat4(1.0f) ),
        mCameraPosition( glm::vec3(0.0f, 0.0f, 0.0f ) ),
        mCameraDirection( glm::vec3(0.0f, 0.0f, -1.0f ) ),
        mCameraLookAtPoint( glm::vec3(0.0f, 0.0f, -1.0f ) ),
        mCameraUpVector( glm::vec3(0.0f, 1.0f, 0.0f ) ),
        mCameraTheta( 0.0f ),
        mCameraPhi( glm::pi<float>() / 2.0f ),
        mCameraRadius( 1.0f ) {
}
 
[[maybe_unused]]
inline void CSCI441::Camera::rotate(const GLfloat dTheta, const GLfloat dPhi) {
    mCameraTheta += dTheta;           // update theta
    mCameraPhi += dPhi;               // update phi
    _clampCameraPhi();                // bounds check phi
    recomputeOrientation();           // convert to cartesian
}
 
inline void CSCI441::Camera::_clampCameraPhi() {
    if(mCameraPhi <= 0.0f) mCameraPhi = 0.0f + 0.001f;
    if(mCameraPhi >= glm::pi<float>()) mCameraPhi = glm::pi<float>() - 0.001f;
}
 
#endif // CSCI441_CAMERA_HPP