CameraGL.cc

Go to the documentation of this file.

#include <gra/camera/CameraGL.h>
#include <gra/camera/PerspProj.h>
#include <gra/camera/OrthoProj.h>

using namespace gra;

void CameraGL::_set_orthogonal_proj(const Projection& proj)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(proj.getLeftPlane(),
            proj.getRightPlane(),
            proj.getBottomPlane(),
            proj.getTopPlane(),
            proj.getNearPlane(),
            proj.getFarPlane());
    glMatrixMode(GL_MODELVIEW);
}

void CameraGL::_set_perspective_proj(const Projection& proj)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(proj.getLeftPlane(),
              proj.getRightPlane(),
              proj.getBottomPlane(),
              proj.getTopPlane(),
              proj.getNearPlane(),
              proj.getFarPlane());
    glMatrixMode(GL_MODELVIEW);
}




CameraGL::CameraGL(AutoPtr<Projection> * pAP)
    : Camera(pAP)
{
    if (dynamic_cast<PerspProj*>(_pProjection))
        _set_perspective_proj(*_pProjection);
    else if (dynamic_cast<OrthoProj*>(_pProjection))
        CameraGL::_set_orthogonal_proj(*_pProjection);
    else {
        cerr << "CameraGL::CameraGL(): Uknown projection type, using orthogonal" << endl;
        CameraGL::_set_orthogonal_proj(*_pProjection);
    }
}

CameraGL::CameraGL(const Camera& src)
    : Camera(src)
{
    if (dynamic_cast<PerspProj*>(_pProjection))
        CameraGL::_set_perspective_proj(*_pProjection);
    else if (dynamic_cast<OrthoProj*>(_pProjection))
        CameraGL::_set_orthogonal_proj(*_pProjection);
    else {
        cerr << "CameraGL::CameraGL(): Uknown projection type, using orthogonal" << endl;
        CameraGL::_set_orthogonal_proj(*_pProjection);
    }

    if (_pTrMat) CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::setOpenGLTransform(const Matrix4& mat)
{
    /*
     * We have transformation of the camera but we want to convert it to
     * the transformation of scene (vertices).
     * Tr. matrix of camera means firstly rotate and then translate.
     * Then we must exchange these operations and to do them
     * in oposite directions. Finally we must transpose consequent metrix
     * because OpenGL requires the "m" matrix have created by
     * scaning columns instead of lines.
     *
     * Have |R t|, want ||R^T 0|*|1 -t||^T = |R^T (R^T*-t)|^T = | R       0|
     *      |0 1|       ||0   1| |0  1||     |0   1       |     |(R^T*-t) 1|
     *
     */

    Matrix4 trMat(mat);
    Matrix3 rMat;
    Vector3 tVec;
    Vector3 sVec;
    float   glMat[16];

    trMat.get(rMat, tVec, sVec);
    rMat.transpose();
    rMat.transform(tVec);
    trMat(3,0) = -tVec.x; trMat(0,3) = 0;
    trMat(3,1) = -tVec.y; trMat(1,3) = 0;
    trMat(3,2) = -tVec.z; trMat(2,3) = 0;
    trMat.get(glMat);
    
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glMultMatrixf(glMat);
}

void CameraGL::setTransform(const Matrix4& trMat)
{
    Camera::setTransform(trMat);
    CameraGL::setOpenGLTransform(trMat);
}

void CameraGL::rotateX(float a)
{
    Camera::rotateX(a);
    CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::rotateY(float a)
{
    Camera::rotateY(a);
    CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::rotateZ(float a)
{
    Camera::rotateZ(a);
    CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::rotate(float a, const Vector3& axis)
{
    Camera::rotate(a, axis);
    CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::translate(float x, float y, float z)
{
    Camera::translate(x, y, z);
    CameraGL::setOpenGLTransform(*_pTrMat);
}

void CameraGL::unsetTransform()
{
    Camera::unsetTransform();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void CameraGL::setProjection(AutoPtr<Projection> * pProj)
{
    Camera::setProjection(pProj);
    
    if (dynamic_cast<PerspProj*>(_pProjection))
        CameraGL::_set_perspective_proj(*_pProjection);
    else if (dynamic_cast<OrthoProj*>(_pProjection))
        CameraGL::_set_orthogonal_proj(*_pProjection);
    else {
        cerr << "CameraGL::etProjection(): Uknown projection type, using orthogonal" << endl;
        CameraGL::_set_orthogonal_proj(*_pProjection);
    }
}

---