source: GTP/trunk/App/Demos/Illum/Illumination Networks Demo [OpenGL]/RESOURCES/include/My3DGraphRes/Camera.h @ 845

#pragma once

#include "Vector.h"
#include <includes.h>

enum Axis
{
        AXIS_X=0,
        AXIS_Y=1,
        AXIS_Z=2
};

class Camera
{
public:
        Camera(void);
        ~Camera(void);

        Vector m_Orientation;

        Vector m_EyePosition;
        Vector m_LookAt;
        Vector m_UpVector;
        Vector m_ViewDirection;
        Vector m_RightVector;
        
protected:      double m_AspectRatio;
        double m_NearClipDistance;
        double m_FarClipDistance;
        double m_FovX;
        double m_FovY;
        double m_LeftCorner;
        double m_RightCorner;
        double m_TopCorner;
        double m_DownCorner;

public:
        void Rotate(Axis axis, double angle);
        void Rotate(Vector rotvec);

        void SetPosition(Vector position)
        {
                m_EyePosition=position;
                m_ViewDirection=m_LookAt-m_EyePosition;
                CalculateRightVector();
        }
        void SetPosition(double x,double y,double z)
        {
                m_EyePosition.x=x;
                m_EyePosition.y=y;
                m_EyePosition.z=z;

                m_ViewDirection=m_LookAt-m_EyePosition;
                CalculateRightVector();
        }

        Vector getPosition(void)
        {
                return m_EyePosition;
        }
        void getPosition(double& x,double&y,double &z)
        {
                x=m_EyePosition.x;
                y=m_EyePosition.y;
                z=m_EyePosition.z;
        }

        void setLookAt(Vector lookat)
        {
                m_LookAt=lookat;
                m_ViewDirection=m_LookAt-m_EyePosition;
                CalculateRightVector();
        //      CalculateUpVector();
        }

        void setLookAt(double x,double y,double z)
        {
                m_LookAt.x=x;
                m_LookAt.y=y;
                m_LookAt.z=z;
                m_ViewDirection=m_LookAt-m_EyePosition;
                CalculateRightVector();
//              CalculateUpVector();
        }

        Vector getLookAt()
        {
                return m_LookAt;
        }
        void  getLookAt(double& x,double&y,double &z)
        {
                x=m_LookAt.x;
                y=m_LookAt.y;
                z=m_LookAt.z;
        }

        void SetUpVector(Vector position)
        {
                m_UpVector=position;
        }
        void SetUpVector(double x,double y,double z)
        {
                m_UpVector.x=x;
                m_UpVector.y=y;
                m_UpVector.z=z;
        }

        Vector getUpVector(void)
        {
                return m_UpVector;
        }
        void getUpVector(double& x,double&y,double &z)
        {
                x=m_UpVector.x;
                y=m_UpVector.y;
                z=m_UpVector.z;
        }

        Vector getRightVector(void)
        {
                return m_RightVector;
        }

        void setFovX(double angle)
        {
                m_FovX=angle;
                UpdateFovY();
        }

        void setFovY(double angle)
        {
                m_FovY=angle;
                UpdateFovX();
        }

        double getFovX(void)
        {
                return m_FovX;
        }

        double getFovY(void)
        {
                return m_FovY;
        }

        void setNearClipDistance(double distance)
        {
                m_NearClipDistance=distance;
        }

        void setFarClipDistance(double distance)
        {
                m_FarClipDistance=distance;
        }

        double getNearClipDistance(void)
        {
                return m_NearClipDistance;
        }

        double getFarClipDistance(void)
        {
                return m_FarClipDistance;
        }
        void setAspectRatio(double ratio)
        {
                m_AspectRatio=ratio;
                UpdateFovY();
        }
        void setCorners(double left,double right,double top,double bottom)
        {
                m_LeftCorner=left;
                m_RightCorner=right;
                m_TopCorner=top;
                m_DownCorner=bottom;
        }
private:
        
        void UpdateCamera(void);
        
        void UpdateFovX(void)
        {
                m_FovX=m_FovY/m_AspectRatio;
        }

        void UpdateFovY(void)
        {
                m_FovY=m_AspectRatio*m_FovX;
        }

        void CalculateRightVector(void)
        {
                Vector X = m_ViewDirection.UnitVector() % m_UpVector;
                X.Normalize();
                m_RightVector=X;
        }
        void CalculateUpVector(void)
        {
                Vector X = m_ViewDirection.UnitVector() % m_RightVector;
                X.Normalize();
                m_UpVector=X;
        }
public:
        void SetViewandProjection(void);
        void SetProjection(void);
        virtual void SetViewandProjectionOrto(void);
        virtual void Move(Axis axis, double distance);
        virtual void setViewforBbox(){}
};