camera.h

Go to the documentation of this file.

#ifndef BALL_VIEW_RENDERING_CAMERA_H
#define BALL_VIEW_RENDERING_CAMERA_H

#ifndef BALL_COMMON_GLOBAL_H
  #include <BALL/COMMON/global.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
  #include <BALL/MATHS/vector3.h>
#endif

#ifndef BALL_MATHS_QUATERNION_H
  #include <BALL/MATHS/quaternion.h>
#endif

namespace BALL
{
  namespace VIEW
  {
    class BALL_VIEW_EXPORT Camera
    {
      public:
        enum ProjectionMode
        {
          PERSPECTIVE = 0,
          ORTHOGRAPHIC
        };


        Camera();

        Camera(const Camera& camera);

        Camera(const Vector3& view_point, const Vector3& look_at, const Vector3& look_up_vector, const ProjectionMode& mode = PERSPECTIVE);

        virtual ~Camera(){}

        Camera& operator = (const Camera& camera);



        void moveRight(float translation)
          { view_point_ += right_vector_*translation; look_at_ += right_vector_*translation; }

        void moveUp(float translation)
          { view_point_ += look_up_vector_*translation; look_at_ += look_up_vector_*translation; }

        void moveForward(float translation)
        {
          Vector3 normal_view_vector(view_vector_);
          normal_view_vector.normalize();
          view_point_ += normal_view_vector*translation;
          look_at_ += normal_view_vector*translation;
        }

        const Vector3& getViewPoint() const
          { return view_point_;}

        void setViewPoint(const Vector3& view_point)
          { view_point_ = view_point; calculateVectors_();}

        const Vector3& getLookAtPosition() const
          { return look_at_;}

        void setLookAtPosition(const Vector3& look_at)
          { look_at_ = look_at; calculateVectors_();}

        const Vector3& getLookUpVector() const
          { return look_up_vector_;}

        void setLookUpVector(const Vector3& look_up_vector)
          { look_up_vector_ = look_up_vector; calculateVectors_();}

        void rotateAboutView(float degree);

        float getDistance() const
          { return view_point_.getDistance(look_at_);}

        Vector3 getViewVector() const
          { return view_vector_;}

        Vector3 getRightVector() const
          { return right_vector_;}

        void translate(const Vector3& v);

        Vector3 convertCameraToSceneCoordinates(const Vector3& v);

        void rotate(const Quaternion& q, const Vector3& origin);

        void rotate(const Matrix4x4& mat, const Vector3& origin);

        virtual void clear()
          { *this = Camera();}

        void setProjectionMode(ProjectionMode const& mode)
        { projection_mode_ = mode; }

        ProjectionMode getProjectionMode() const
        { return projection_mode_; }

        String toString() const;

        bool readFromString(const String& data);



        bool operator == (const Camera& camera) const;

        bool operator < (const Camera& camera) const;


        virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

      protected:
        //_
        void calculateVectors_();

        //_
        Vector3 view_point_;

        //_
        Vector3 look_at_;

        //_
        Vector3 look_up_vector_;

        /*_ The viewing vector.
            Stored only for better performance in the scene.
        */
        Vector3 view_vector_;

        /*_ The orthogonal vector to the viewing vector, which is showing to the right.
            Stored only for better performance in the scene.
        */
        Vector3 right_vector_;

        /* The projection mode used by this camera.
         */
        ProjectionMode    projection_mode_;
    };

  } // namespace VIEW
} // namespace BALL

#endif //BALL_VIEW_RENDERING_CAMERA_H