Camera.h

Go to the documentation of this file.

#ifndef GlobeEngine_Camera_h
#define GlobeEngine_Camera_h

#include "OpenGL_Includes.h"
#include <vmmlib/vmmlib.hpp>
#include "ViewFrustum.h"

namespace ge {
    
    class Camera
    {
    public:
        enum CAMERATYPE { NORMAL, ARCBALL, STRATEGIC };
        enum AXIS {XZ_AXIS = 0, XY_AXIS, YZ_AXIS };
        
    public:
        
        Camera();
        ~Camera ();
 
        // hidden overrides from component
        virtual void changeSetup(ViewFrustumProperties _in);
        virtual void clear();
        virtual void destroy();
        virtual void update() = 0;
        virtual void calculateViewMatrix()=0;
        virtual void print();
        
        void setOrthographic();
        void setPerspective(int _w = 0, int _h = 0);
        void setOrthoCoordinates(vmml::Vector4d _coords);
        void setViewportSize(int _w, int _h);
        void setViewportSize(vmml::Vector2d _viewport);
        vmml::Vector2d getScreenposForPoint(vmml::Vector3d _p, vmml::Matrix4d _modelMatrix);
        
        enum Camera::AXIS getOrientationAxis();
        enum Camera::AXIS getOrientationFromString(std::string _input);
        void setOrientationAxis(enum AXIS _in);
        
        vmml::Vector2d getViewport() const;
        void applyViewport();
        std::shared_ptr<ge::ViewFrustum> const& getViewFrustum() const;
        
        vmml::Matrix4d getViewMatrix() const;
        void setViewMatrix(vmml::Matrix4d _viewMatrix);
        vmml::Vector3d getRelativePositionToCenter() const;
        vmml::Vector3d getScenePosition() const;
        void setScenePosition(vmml::Vector3d _pos);
        void setRelativePositionToCenter(vmml::Vector3d _pos);
        double getDistanceToCamera(vmml::Vector3d _p) const;
        vmml::Vector3d getDirection() const;

        enum CAMERATYPE getType() { return type; };
        
        bool hasChanged() { return changed; };
        vmml::Matrix4d getProjectionMatrix() const;
        void setProjectionMatrix(vmml::Matrix4d _projectionMatrix);
        vmml::Matrix4d getViewProjectionMatrix() const;
        void setViewProjectionMatrix(vmml::Matrix4d _viewprojectionMatrix);
        static vmml::Matrix4d createOrthoProjectionMatrix(double l, double r, double b, double t, double n, double f);
        void enableOrthoProjection();
        void disableOrthoProjection();
        void setChanged();

        vmml::Matrix4d getInverseViewMatrix() const;
        vmml::Matrix4d getInverseProjectionMatrix() const;
        vmml::Matrix4d getInverseProjectionViewMatrix() const;

        vmml::Vector4d getOrthoCoordinates() const;

    protected:
        void moveFrustum();
        void setStandardVectors();

        vmml::Matrix4d createPerspectiveProjectionMatrix(double fovy, double aspect, double zNear, double zFar);
        vmml::Matrix4d createFrustumMatrix(double  left, double  right,
                                        double  bottom, double  top,
                                        double  zNear, double zFar);

        vmml::Matrix4d getRotationMatrix(const vmml::Quaterniond& quat);
        
        enum CAMERATYPE type;
        enum Camera::AXIS orientation_axis;
        
        std::shared_ptr<ge::ViewFrustum> viewfrustum;
        vmml::Vector2d viewport;

        vmml::Vector3d camPosition;
        vmml::Vector3d camRight;
        vmml::Vector3d camUp;
        vmml::Vector3d camDirection;

        vmml::Matrix4d viewMatrix;
        vmml::Matrix4d projectionMatrix;
        /* viewProjectionMatrix is only a storage for faster access while rendering */
        vmml::Matrix4d viewProjectionMatrix;
        
        vmml::Matrix4d perspectiveProjectionMatrix;
        vmml::Matrix4d orthoProjectionMatrix;
        vmml::Vector4d orthoCoord;

        bool changed;
        bool orthoProjMode;
        
        /* uniform camera objects */
        GLuint cameraBuffers[2];        
    };
}
#endif