Camera.hpp

#pragma once
 
#include <Core/Math/Math.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Observable.hpp>
namespace Ra {
namespace Core {
namespace Asset {
 
class RA_CORE_API Camera
{
  public:
    enum class ProjType { ORTHOGRAPHIC, PERSPECTIVE };
 
    Camera( Scalar height = 1_ra, Scalar width = 1_ra );
 
    ~Camera() = default;
 
    Camera& operator=( const Camera& rhs );
 
    inline Core::Transform getFrame() const;
 
    inline void setFrame( const Core::Transform& frame );
 
    inline Core::Vector3 getPosition() const;
 
    inline void setPosition( const Core::Vector3& position );
 
    inline Core::Vector3 getDirection() const;
 
    void setDirection( const Core::Vector3& direction );
 
    inline Core::Vector3 getUpVector() const;
 
    inline void setUpVector( const Core::Vector3& upVector );
 
    inline Core::Vector3 getRightVector() const;
 
    //
    // Utility functions
    //
 
    // Note : in all screen pixels coordinates function, Y is taken to be in standard UI-libs style
    // coordinates, i.e. Y=0 is the top line and Y=height is the bottom line.
 
    Core::Ray getRayFromScreen( const Core::Vector2& pix ) const;
 
    Core::Vector3 projectToScreen( const Core::Vector3& p ) const;
 
    Core::Vector3 projectToNDC( const Core::Vector3& p ) const;
 
    Core::Vector3 unProjectFromScreen( const Core::Vector2& pix ) const;
 
    Core::Vector3 unProjectFromScreen( const Core::Vector3& pix ) const;
 
    Core::Vector3 unProjectFromNDC( const Core::Vector3& pix ) const;
 
    //
    // Getters and setters for projection matrix parameters.
    //
 
    inline ProjType getType() const;
 
    inline void setType( const ProjType& projectionType );
 
    inline Scalar getZoomFactor() const;
 
    inline void setZoomFactor( const Scalar& zoomFactor );
 
    inline Scalar getFOV() const;
 
    inline void setFOV( Scalar fov );
 
    inline Scalar getMinZNear() const;
    inline Scalar getMinZRange() const;
 
    inline Core::Matrix4 getProjMatrix() const;
    inline Core::Matrix4 getViewMatrix() const;
 
    void updateProjMatrix();
 
    inline void setProjMatrix( Core::Matrix4 projMatrix );
 
    inline Scalar getZNear() const;
 
    inline void setZNear( Scalar zNear );
 
    inline Scalar getZFar() const;
 
    inline void setZFar( Scalar zFar );
 
    inline Scalar getWidth() const;
 
    inline Scalar getHeight() const;
 
    inline Scalar getAspect() const;
 
    inline void setXYmag( Scalar xmag, Scalar ymag );
 
    inline std::pair<Scalar, Scalar> getXYmag() const;
 
    void setViewport( Scalar width, Scalar height );
 
    void applyTransform( const Core::Transform& T );
 
    void fitZRange( const Core::Aabb& aabb );
 
    const Scalar m_minZNear { 0.01_ra };
    const Scalar m_minZRange { 0.01_ra };
 
    static Core::Matrix4 perspective( Scalar a, Scalar y, Scalar n, Scalar f );
 
    static Core::Matrix4 frustum( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
 
    static Core::Matrix4 ortho( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
 
  private:
    Core::Transform m_frame { Core::Transform::Identity() };
 
    Core::Matrix4 m_projMatrix { Core::Matrix4::Identity() }; 
 
    Scalar m_width { 1_ra };  
    Scalar m_height { 1_ra }; 
    Scalar m_aspect {
        1_ra }; 
 
    ProjType m_projType { ProjType::PERSPECTIVE }; 
    Scalar m_zoomFactor { 1_ra };                  
    Scalar m_zNear { 0.1_ra };                     
    Scalar m_zFar { 1000_ra };                     
 
    Scalar m_fov { Core::Math::PiDiv4 }; 
 
    Scalar m_xmag { 1_ra };
    Scalar m_ymag { 1_ra };
};
 
inline Core::Transform Camera::getFrame() const {
    return m_frame;
}
 
inline void Camera::setFrame( const Core::Transform& frame ) {
    m_frame = frame;
}
 
inline Core::Vector3 Camera::getPosition() const {
    return ( m_frame.translation() );
}
 
inline void Camera::setPosition( const Core::Vector3& position ) {
    Core::Transform T = Core::Transform::Identity();
    T.translation()   = position - m_frame.translation();
    applyTransform( T );
}
 
inline Core::Vector3 Camera::getDirection() const {
    return ( -m_frame.linear().block<3, 1>( 0, 2 ) ).normalized();
}
 
inline Core::Vector3 Camera::getUpVector() const {
    return ( m_frame.affine().block<3, 1>( 0, 1 ) );
}
 
inline void Camera::setUpVector( const Core::Vector3& upVector ) {
    Core::Transform T = Core::Transform::Identity();
    T.rotate( Core::Quaternion::FromTwoVectors( getUpVector(), upVector ) );
    applyTransform( T );
}
 
inline Core::Vector3 Camera::getRightVector() const {
    return ( m_frame.affine().block<3, 1>( 0, 0 ) );
}
 
inline Scalar Camera::getFOV() const {
    return m_fov;
}
 
inline void Camera::setFOV( Scalar fov ) {
    m_fov = fov;
    // update m_xmag and m_ymag according to the perspective parameters (heuristic)
    m_xmag = 2_ra * std::tan( m_fov / 2_ra );
    m_ymag = m_xmag;
    updateProjMatrix();
}
 
inline Scalar Camera::getZNear() const {
    return m_zNear;
}
 
inline void Camera::setZNear( Scalar zNear ) {
    m_zNear = zNear;
    updateProjMatrix();
}
 
inline Scalar Camera::getZFar() const {
    return m_zFar;
}
 
inline void Camera::setZFar( Scalar zFar ) {
    m_zFar = zFar;
    updateProjMatrix();
}
 
inline Scalar Camera::getZoomFactor() const {
    return m_zoomFactor;
}
 
inline void Camera::setZoomFactor( const Scalar& zoomFactor ) {
    m_zoomFactor = zoomFactor;
    updateProjMatrix();
}
 
inline Scalar Camera::getWidth() const {
    return m_width;
}
 
inline Scalar Camera::getHeight() const {
    return m_height;
}
 
inline Scalar Camera::getAspect() const {
    return m_aspect;
}
 
inline Camera::ProjType Camera::getType() const {
    return m_projType;
}
 
inline void Camera::setType( const ProjType& projectionType ) {
    m_projType = projectionType;
}
 
inline Core::Matrix4 Camera::getViewMatrix() const {
    return getFrame().inverse().matrix();
}
 
inline Core::Matrix4 Camera::getProjMatrix() const {
    return m_projMatrix;
}
 
inline Scalar Camera::getMinZNear() const {
    return m_minZNear;
}
 
inline Scalar Camera::getMinZRange() const {
    return m_minZRange;
}
 
inline void Camera::setProjMatrix( Core::Matrix4 projMatrix ) {
    m_projMatrix = projMatrix;
}
 
inline void Camera::setXYmag( Scalar xmag, Scalar ymag ) {
    m_xmag = xmag;
    m_ymag = ymag;
    // update m_fov according to  orthographic parameters (heuristic)
    m_fov = std::atan2( m_xmag * 2, 1_ra );
    updateProjMatrix();
}
 
inline std::pair<Scalar, Scalar> Camera::getXYmag() const {
    return { m_xmag, m_ymag };
}
 
} // namespace Asset
} // namespace Core
} // namespace Ra