source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/Standalone/Hierarchical Systems Demo [OpenGL]/RESOURCES/include/My3DGraphRes/Camera.h @ 3255

#ifndef camera_h
#define camera_h

#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);

        virtual void SetPosition(Vector position)
        {
                m_EyePosition=position;
                m_ViewDirection=m_LookAt-m_EyePosition;
        //      CalculateRightVector();
        }
        virtual 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 setRightVector(Vector v)
        {
                m_RightVector=v;
        }


        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 SetViewandProjectionNew(void);
        
        void SetProjection(void);
        virtual void SetViewandProjectionOrto(void);
        virtual void Move(Axis axis, double distance);
        virtual void setViewforBbox()
        {
                gluLookAt(0,0,0,
                        m_ViewDirection.x,
                        m_ViewDirection.y,
                        m_ViewDirection.z,
                        m_UpVector.x,
                        m_UpVector.y,
                        m_UpVector.z);
        }
};

#endif