Eigene Dateien/FlowVis/src/VCamera.cpp

Go to the documentation of this file.

#include "VCamera.h"

VCamera::VCamera() : mFov(45.0f), mNearPlane(0.001f), mPosition(), mOrientation(),
        mViewMatrix(), mProjMatrix(), mScreenDistance(3.5f),
        mEyeSeparation(0.06f), mMustUpdateProjection(true), mMustUpdateView(true),
        mOrthogonalCamera(false), mOrthogonalSize(), mIsShadowCamera(false)
{
                // Initalize all our member variables.
                mAspectRatio = 1.0f + (1.0f / 3.0f);
                mFarPlane = 100.0f;
}

void VCamera::setProjection(int width, int height)
{
        if (height == 0)
    {
        height = 1;
    }

    mAspectRatio = (float)width / (float)height;

        mMustUpdateProjection = true;
    updateProjMatrix();
}

void VCamera::updateProjMatrix()
{
        if(mMustUpdateProjection)
        {
                if(mOrthogonalCamera)
                {
                        /*mProjMatrix.loadIdentity();
                        mProjMatrix[0] = 1.0f / mOrthogonalSize.x /2.0f;
                        mProjMatrix[5] = 1.0f / mOrthogonalSize.y  /2.0f;
                        mProjMatrix[10] = 1.0f / mFarPlane;
                        mProjMatrix[15] = 1.0f;
                        */
                        float right = 1.1f;//mOrthogonalSize.getX() / 662.0f;
                        float left = -right;
                        float top = 1.1f;//mOrthogonalSize.getY() / 662.0f;
                        float bottom = -top;

                        mProjMatrix.clearMatrix();
                        mProjMatrix[0] = 2.0f / (right - left);
                        mProjMatrix[5] = 2.0f / (top - bottom);
                        mProjMatrix[10] = (-2.0f / (mFarPlane - mNearPlane));
                        mProjMatrix[12] = - (right + left) / (right - left);
                        mProjMatrix[13] = - (top + bottom) / (top - bottom);
                        mProjMatrix[14] = - (mFarPlane + mNearPlane) / (mFarPlane - mNearPlane);
                        mProjMatrix[15] = 1.0f;
                        
                }
                else
                {
                        float radian = ( PI/ 180) * (mFov/2);
                        float tanFov = ::tan(radian);
                        float right = mAspectRatio * tanFov * mNearPlane;
                        float left = -right; 
                        float top = tanFov * mNearPlane;
                        float bottom = -top;

                        mProjMatrix[0] = (2.0f * mNearPlane) / (right - left);
                        mProjMatrix[5] = (2.0f * mNearPlane) / (top - bottom);
                        mProjMatrix[8] = (right + left) / (right - left);
                        mProjMatrix[9] = (top + bottom) / (top - bottom);
                        mProjMatrix[10] = (-(mFarPlane + mNearPlane)) / (mFarPlane - mNearPlane);
                        mProjMatrix[11] = -1.0f;
                        mProjMatrix[14] = (-(2.0f * mNearPlane * mFarPlane) / (mFarPlane - mNearPlane));
                        mProjMatrix[15] = 0.0f;
                }
                mMustUpdateProjection = false;
        }
}

void VCamera::updateProjMatrixLeft()
{
        if(mMustUpdateProjection)
        {
                this->updateProjMatrix();
        }
        VMatrix asymMatrix;
        asymMatrix[8] = mEyeSeparation / (2.0f * mScreenDistance);

        mLeftProjMatrix = mProjMatrix * asymMatrix;
}

void VCamera::updateProjMatrixRight()
{
        if(mMustUpdateProjection)
        {
                this->updateProjMatrix();
        }

        VMatrix asymMatrix;
        asymMatrix[8] = -mEyeSeparation / (2.0f * mScreenDistance);

        mRightProjMatrix = mProjMatrix * asymMatrix;
}

void VCamera::setProjectionToInfinity()
{
    mProjMatrix[10] = -1.0f;// + INFINITY_PROJECTION_EPSILON;
    mProjMatrix[14] = -2.0f * mNearPlane; //* (INFINITY_PROJECTION_EPSILON - 1.0f);
}

void VCamera::setProjectionToNormal()
{
    mProjMatrix[10] = (mFarPlane + mNearPlane) / (mNearPlane - mFarPlane);
    mProjMatrix[14] = (2 * mNearPlane * mFarPlane) / (mNearPlane - mFarPlane);
}

void VCamera::rotateX(float m_degrees)
{
        mOrientation.normalize();
   mOrientation.applyRotationX(-m_degrees);
   mMustUpdateView = true;
}

void VCamera::rotateY(float m_degrees)
{
        mOrientation.normalize();
    mOrientation.applyRotationY(-m_degrees);
        mMustUpdateView = true;
}

void VCamera::rotateZ(float m_degrees)
{
        mOrientation.normalize();
    mOrientation.applyRotationZ(-m_degrees);
        mMustUpdateView = true;
}

void VCamera::rotate(float m_degrees, float ax, float ay, float az)
{
        mOrientation.normalize();
        
    mOrientation.applyRotationZ(-m_degrees);
        mMustUpdateView = true;
}

void VCamera::lookInDirection(VVector eye, VVector view, VVector up)
{
        VVector side;

        mViewMatrix.clearMatrix();

        view.normalize();
        up.normalize();

        /* Side = forward x up */
        side = view.getCross(up);
        side.normalize();

        up = side.getCross(view);
        up.normalize();

        //std::cout << "up" << up << std::endl;

        mViewMatrix[0] = side.getX();
        mViewMatrix[4] = side.getY();
        mViewMatrix[8] = side.getZ();

        mViewMatrix[1] = up.getX();
        mViewMatrix[5] = up.getY();
        mViewMatrix[9] = up.getZ();

        mViewMatrix[2] = -view.getX();
        mViewMatrix[6] = -view.getY();
        mViewMatrix[10] = -view.getZ();

        mViewMatrix.translate(-eye);
        
        mPosition = eye;

    mOrientation = mViewMatrix.getRotation();
    mOrientation.normalize();

        mMustUpdateView = false;

        /*std::cout << "campos:" << eye.getX() << ";" << eye.getY() << ";" << eye.getZ() << std::endl;
        std::cout << "view:" << view.getX() << ";" << view.getY() << ";" << view.getZ() << std::endl;
        std::cout << "up:" << up.getX() << ";" << up.getY() << ";" << up.getZ() << std::endl;
        std::cout << "side:" << side.getX() << ";" << side.getY() << ";" << side.getZ() << std::endl;*/

}

void VCamera::updateViewMatrix()
{
        if(mMustUpdateView)
        {
                mOrientation.normalize();
                VQuaternion tmpQ = mOrientation.getInverse();
                mViewMatrix.clearMatrix();
                mViewMatrix.rotate(tmpQ);
                VVector tmpV = - mPosition;
                mViewMatrix.translate(tmpV);

                mMustUpdateView = false;
        }
}

void VCamera::updateViewMatrixLeft()
{
        if(mMustUpdateView)
        {
                updateViewMatrix();
        }
        VMatrix asymMatrix;
        asymMatrix[12] = 0.5f * mEyeSeparation * mScreenDistance;

        mLeftViewMatrix = asymMatrix * mViewMatrix;
}

void VCamera::updateViewMatrixRight()
{
        if(mMustUpdateView)
        {
                updateViewMatrix();
        }
        VMatrix asymMatrix;
        asymMatrix[12] = -0.5f * mEyeSeparation * mScreenDistance;

        mRightViewMatrix = asymMatrix * mViewMatrix;
}

void VCamera::mouseMove(float x, float y, float z)
{
        VQuaternion rot_x(VVector(1.0f, 0.0f, 0.0f), -x);
        VQuaternion rot_y(VVector(0.0f, 1.0f, 0.0f), -y);
        
        if(x == 0)
        {
                rot_x = VQuaternion();
        }

        if(y == 0)
        {
                rot_y = VQuaternion();
        }

        mOrientation = rot_y * mOrientation * rot_x;
        mMustUpdateView = true;
}

void VCamera::moveForward(float way)
{
        mPosition += mOrientation.getForwardVector()  * way;
        
        mMustUpdateView = true;
}

void VCamera::moveSideWards(float way)
{
        mPosition +=  mOrientation.getRightVector() * way;
        
        mMustUpdateView = true;
}

void VCamera::setStereoParameters(float m_ScreenDistance, float m_EyeSeparation)
{
        mScreenDistance = m_ScreenDistance;
        mEyeSeparation = m_EyeSeparation;
        mMustUpdateProjection = true;
}

---