Eigene Dateien/FlowVis/src/VCamera.h

Go to the documentation of this file.

#pragma once

#ifndef __camera_h
#define __camera_h

#include "VMatrix.h"
#include "VQuaternion.h"

class VCamera
{
public:
        VCamera();

        void setProjection(int width, int height);

        void updateProjMatrix();

        void updateProjMatrixLeft();

        void updateProjMatrixRight();

        void setProjectionToInfinity();

        void setProjectionToNormal();

        void rotateX(float m_degrees);

        void rotateY(float m_degrees);

        void rotateZ(float m_degrees);

        void rotate(float m_degrees, float ax, float ay, float az);

        void lookInDirection(VVector eye, VVector view, VVector up);

        void updateViewMatrix();

        void updateViewMatrixLeft();

        void updateViewMatrixRight();

        void mouseMove(float x, float y, float z);

        void moveForward(float way);

        void moveSideWards(float way);

        const VMatrix getViewMatrix() const
        {
                return mViewMatrix;
        }

        void setViewMatrix(const VMatrix& m)
        {
                mViewMatrix = m;
                mMustUpdateView = false;
        }

        const VMatrix getProjMatrix() const
        {
                return mProjMatrix;
        }

        void setProjMatrix(const VMatrix& m)
        {
                mProjMatrix = m;
        }

        const VQuaternion getOrientation() const
        {
                return mOrientation;
        }

        void setOrientation(const VQuaternion& q)
        {
                mOrientation = q;
        }

        const VVector getPosition() const
        {
                return mPosition;
        }

        VVector getUpVector()
        {
                return mOrientation.getUpVector();
        }

        VVector getAtVector()
        {
                return mOrientation.getForwardVector();
        }

        void setPosition(VVector& v)
        {
                mPosition = v;
                mMustUpdateView = true;
        }

        float * getViewMatrix()
        {
                return &mViewMatrix[0];
        }

        float * getProjectionMatrix()
        {
                return &mProjMatrix[0];
        }

        float getFov() const
        {
                return mFov;
        }

        void setFov(float m_fov)
        {
                mFov = m_fov;
                mMustUpdateProjection = true;
        }

        float getAspecRatio() const
        {
                return mAspectRatio;
        }

        void setAspectRatio(float m_aspect)
        {
                mAspectRatio = m_aspect;
                mMustUpdateProjection = true;
        }

        void setStereoParameters(float m_ScreenDistance, float m_EyeSeparation);

        void setOrthogonalCamera(VVector m_OrthogonalSize, bool m_OrthogonalCamera = true)
        {
                mOrthogonalCamera = m_OrthogonalCamera;
                mOrthogonalSize = m_OrthogonalSize;
                mMustUpdateProjection = true;
        }

        void setAsShadowCamera(bool m_IsShadow)
        {
                mIsShadowCamera = m_IsShadow;
        }


private:
        
        float mFov; 
        float mAspectRatio; 
        float mNearPlane; 
        float mFarPlane; 
        VQuaternion mOrientation; 
        VVector mPosition; 
        VMatrix mViewMatrix; 
        VMatrix mLeftViewMatrix; 
        VMatrix mRightViewMatrix; 
        VMatrix mProjMatrix; 
        VMatrix mLeftProjMatrix; 
        VMatrix mRightProjMatrix; 
        //values for stereo
        float mEyeSeparation;   
        float mScreenDistance; 
        bool mMustUpdateProjection;     
        bool mMustUpdateView;           
        bool mOrthogonalCamera;                 
        VVector mOrthogonalSize;        
        bool mIsShadowCamera;                   
};


#endif

---