camera.cpp

Go to the documentation of this file.

/* MAINTAINER: Martin */

#include "camera.h"

#include "application_client.h"

Camera::Camera(void):
        mPosition(0.0),
        mReferencePoint(0.0, 0.0, -1.0),
        mUpVector(0.0, 1.0, 0.0)
{
}

Camera::Camera(const GLVector3d & pos, const GLVector3d & ref, const GLVector3d & up):
        mPosition(pos), mReferencePoint(ref), mUpVector(up)
{}

Camera::~Camera(void)
{}

void Camera::setPerspective(const GLdouble fovx, const GLdouble aspect, const GLdouble zNear, const GLdouble zFar)
{
        mPerspectiveChanged = mPerspective.fovx != fovx || mPerspective.aspect != aspect || mPerspective.zNear != zNear || mPerspective.zFar != zFar;
        if (mPerspectiveChanged)
        {
                mPerspective.fovx       = fovx;
                mPerspective.aspect     = aspect;
                mPerspective.zNear      = zNear;
                mPerspective.zFar       = zFar;
        }
}

void Camera::computeLookAt(GLMatrix4d &m)
{
        GLVector3d forward, center, up, side, eye;
        getRef(center);
        getPos(eye);
        getUp(up);

        forward = center - eye;
        forward.normalize();
        (side = forward).cross(up).normalize();
        (up = side).cross(forward);
        
        m[3] = m[7] = m[11] = m[12] = m[13] = m[14] = 0; m[15] = 1;

        m[0] = side.x;
    m[4] = side.y;
    m[8] = side.z;

    m[1] = up.x;
    m[5] = up.y;
    m[9] = up.z;

    m[2]  = -forward.x;
    m[6]  = -forward.y;
    m[10] = -forward.z;

        m.applyTranslate(-eye);
}

void Camera::computePerspective(GLMatrix4d &m)
{       
        // This code is based off the MESA source for gluPerspective
/*
        if (!mPerspectiveChanged)
        {
*/
                GLdouble xmin, xmax, ymin, ymax;
                
                xmax = mPerspective.zNear * tan(mPerspective.fovx * M_PI / 360.0);
                xmin = -xmax;
                   
                ymin = xmin / mPerspective.aspect;
                ymax = xmax / mPerspective.aspect;
                
                m[1] = m[2] = m[3] = m[4] = m[6] = m[7] = m[12] = m[13] = m[15] = 0;
                
                // Set up the projection matrix
                m[0] = (GLdouble)((2.0 * mPerspective.zNear) / (xmax - xmin));
                m[5] = (GLdouble)((2.0 * mPerspective.zNear) / (ymax - ymin));
                m[10] = -(GLdouble)((mPerspective.zFar + mPerspective.zNear) / (mPerspective.zFar - mPerspective.zNear));
                
                m[8] = (GLdouble)((xmax + xmin) / (xmax - xmin));
                m[9] = (GLdouble)((ymax + ymin) / (ymax - ymin));
                m[11] = -1.0f;
                
                m[14] = -(GLdouble)((2.0 * mPerspective.zFar * mPerspective.zNear) / (mPerspective.zFar - mPerspective.zNear));
/*      }*/
}               
                
void Camera::gluLookAt()
{
        GLMatrix4d m;
        computeLookAt(m);
        m.glMultMatrix();
}

void Camera::gluPerspective()
{
        GLMatrix4d m;
        computePerspective(m);
        m.glMultMatrix();
}

void Camera::computeFrustum()
{
        // compute combo-matrix for frustum calculation
        GLMatrix4d mv, mp;
        computePerspective(mp);
        computeLookAt(mv);
        
        // set new frustum
        mFrustum.set(mp * mv, true);
}

void Camera::setView()
{
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        this->gluPerspective();

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        this->gluLookAt();
}

---