renderer_camera.h

Go to the documentation of this file.

#pragma once

#ifndef RENDERER_CAMERA_H
#define RENDERER_CAMERA_H


/**
    \file
    \brief Contains Renderer::Camera class.
*/




#include "vector.h"

#include <cmath>




namespace Renderer {




/*==============================================================================
    Camera class
==============================================================================*/


/**
    \brief Camera class.

    Represents a [camera matrix](http://en.wikipedia.org/wiki/Camera_matrix),
    consisting of a position, three vectors, and a zoom level. Following
    convention, the \c Z vector points backwards (i.e. towards the observer,
    from the scene), the \c Y vector points up (i.e. towards the top of the
    screen), and the \c X vector points right (i.e. the right side of the
    screen). Pictorially:

          |Y
          |
          P----X
         /
        /Z

    Where the observer (at position \c P) is looking along the direction
    opposite \c Z, with \c Y and \c X defining the orientation of the viewing
    frustum. The 3x4 camera matrix is simply <tt>[X,Y,Z,P]</tt>.
*/
struct Camera {

    /// \brief Initializes a Camera matrix, and orthonormalizes the vectors.
    inline Camera(
        Vector< double, 3 > const& xx,
        Vector< double, 3 > const& yy,
        Vector< double, 3 > const& zz,
        Vector< double, 3 > const& position,
        double const zoom = 1
    );


    inline Vector< double, 3 > const& VectorX()  const;    ///< Returns the X vector.
    inline Vector< double, 3 > const& VectorY()  const;    ///< Returns the Y vector.
    inline Vector< double, 3 > const& VectorZ()  const;    ///< Returns the Z vector.
    inline Vector< double, 3 > const& Position() const;    ///< Returns the position.
    inline double const& Zoom() const;                     ///< Returns the zoom level.


    inline void MoveRight(    double const distance );    ///< Move the camera right (in camera coordinates) by the specified \p distance.
    inline void MoveUp(       double const distance );    ///< Move the camera up (in camera coordinates) by the specified \p distance.
    inline void MoveBackward( double const distance );    ///< Move the camera backwards (in camera coordinates) by the specified \p distance.

    inline void MoveLeft(    double const distance );    ///< Move the camera left (in camera coordinates) by the specified \p distance.
    inline void MoveDown(    double const distance );    ///< Move the camera down (in camera coordinates) by the specified \p distance.
    inline void MoveForward( double const distance );    ///< Move the camera forwards (in camera coordinates) by the specified \p distance.

    inline void TurnCounterclockwise( double const angle );    ///< Roll the camera counterclockwise (in camera coordinates) by the specified \p angle (measured in radians).
    inline void TurnDown(             double const angle );    ///< Yaw the camera down (in camera coordinates) by the specified \p angle (measured in radians).
    inline void TurnLeft(             double const angle );    ///< Pitch the camera left (in camera coordinates) by the specified \p angle (measured in radians).

    inline void TurnClockwise( double const angle );    ///< Roll the camera clockwise (in camera coordinates) by the specified \p angle (measured in radians).
    inline void TurnUp(        double const angle );    ///< Yaw the camera up (in camera coordinates) by the specified \p angle (measured in radians).
    inline void TurnRight(     double const angle );    ///< Pitch the camera right (in camera coordinates) by the specified \p angle (measured in radians).

    inline void ZoomOut( double const amount   );    ///< Zooms in by the specified \p amount.
    inline void ZoomIn(  double const amount   );    ///< Zooms in by the specified \p amount.
    inline void ZoomTo(  double const zoom = 1 );    ///< Sets the zoom level.


    inline void Normalize();    ///< Orthonormalize the X, Y and Z vectors.


private:

    Vector< double, 3 > m_xx;
    Vector< double, 3 > m_yy;
    Vector< double, 3 > m_zz;
    Vector< double, 3 > m_position;
    double m_zoom;
};




/*==============================================================================
    Camera methods
==============================================================================*/


Camera::Camera(
    Vector< double, 3 > const& xx,
    Vector< double, 3 > const& yy,
    Vector< double, 3 > const& zz,
    Vector< double, 3 > const& position,
    double const zoom
) :
    m_xx( xx ),
    m_yy( yy ),
    m_zz( zz ),
    m_position( position ),
    m_zoom( zoom )
{
    assert( m_zoom > 0 );
    Normalize();
}


Vector< double, 3 > const& Camera::VectorX() const {

    return m_xx;
}


Vector< double, 3 > const& Camera::VectorY() const {

    return m_yy;
}


Vector< double, 3 > const& Camera::VectorZ() const {

    return m_zz;
}


Vector< double, 3 > const& Camera::Position() const {

    return m_position;
}


double const& Camera::Zoom() const {

    return m_zoom;
}


void Camera::MoveRight( double const distance ) {

    m_position += m_xx * distance;
}


void Camera::MoveUp( double const distance ) {

    m_position += m_yy * distance;
}


void Camera::MoveBackward( double const distance ) {

    m_position += m_zz * distance;
}


void Camera::MoveLeft( double const distance ) {

    MoveRight( -distance );
}


void Camera::MoveDown( double const distance ) {

    MoveUp( -distance );
}


void Camera::MoveForward( double const distance ) {

    MoveBackward( -distance );
}


void Camera::TurnCounterclockwise( double const angle ) {

    Vector< double, 3 > const xx = m_xx;
    Vector< double, 3 > const yy = m_yy;
    double const cosine = std::cos( angle );
    double const sine   = std::sin( angle );

    m_xx = xx * cosine + yy * sine;
    m_yy = yy * cosine - xx * sine;
}


void Camera::TurnDown( double const angle ) {

    Vector< double, 3 > const yy = m_yy;
    Vector< double, 3 > const zz = m_zz;
    double const cosine = std::cos( angle );
    double const sine   = std::sin( angle );

    m_yy = yy * cosine + zz * sine;
    m_zz = zz * cosine - yy * sine;
}


void Camera::TurnLeft( double const angle ) {

    Vector< double, 3 > const zz = m_zz;
    Vector< double, 3 > const xx = m_xx;
    double const cosine = std::cos( angle );
    double const sine   = std::sin( angle );

    m_zz = zz * cosine + xx * sine;
    m_xx = xx * cosine - zz * sine;
}


void Camera::TurnClockwise( double const angle ) {

    TurnCounterclockwise( -angle );
}


void Camera::TurnUp( double const angle ) {

    TurnDown( -angle );
}


void Camera::TurnRight( double const angle ) {

    TurnLeft( -angle );
}


void Camera::ZoomOut( double const amount ) {

    m_zoom = std::exp( std::log( m_zoom ) + amount );
}


void Camera::ZoomIn( double const amount ) {

    ZoomIn( -amount );
}


void Camera::ZoomTo( double const zoom ) {

    assert( zoom > 0 );
    m_zoom = zoom;
}


void Camera::Normalize() {

    /*
        Orthonormalize using Gram-Schmidt, progressing from the "most
        important" to "least important" directions. The left/right vector will
        change most, forward/backward least, and up/down in-between.
    */

    m_zz /= m_zz.Norm();

    m_yy -= Dot( m_yy, m_zz ) * m_zz;
    m_yy /= m_yy.Norm();

    m_xx -= Dot( m_xx, m_zz ) * m_zz;
    m_xx -= Dot( m_xx, m_yy ) * m_yy;
    m_xx /= m_xx.Norm();
}




}    // namespace Renderer




#endif    // RENDERER_CAMERA_H