Camera.cpp

#include "Camera.h"
#include "Utility.h"

#define PLANE_FRONT             0
#define PLANE_BACK              1
#define PLANE_LEFT              2
#define PLANE_RIGHT             3
#define PLANE_BOTTOM    4
#define PLANE_TOP               5

Camera::Camera ()
{
        angle = CAMERA_STANDARD_ANGLE;
        aspect_ratio = CAMERA_STANDARD_RATIO;
        near_cutoff = CAMERA_STANDARD_NEAR;
        far_cutoff = CAMERA_STANDARD_FAR;

        position = new PositionPath ();
}

Camera::~Camera ()
{
        // do not do anything
}

void Camera::SetAttributes (double a, double a_r, double n, double f)
{
        angle = a;
        aspect_ratio = a_r;
        near_cutoff = n;
        far_cutoff = f;
}

void Camera::ApplyAttributes ()
{
        int previous_mode;

        glGetIntegerv (GL_MATRIX_MODE, &previous_mode);
        glMatrixMode (GL_PROJECTION);
        glLoadIdentity ();
        gluPerspective (angle, aspect_ratio, near_cutoff, far_cutoff);
        glMatrixMode (previous_mode);
}

void Camera::ApplyPosition (int time)
{
        Position pos;

        pos = position->GetPosition (time);

        // since our camera does look along the positive x direction (not positive z as in OpenGL),
        //we have to rotate a bit first.
        glRotatef (90, 0.0f, 1.0f, 0.0f);
        glRotatef (-90, 1.0f, 0.0f, 0.0f);

        // applying the camera position is the exact same as shifting the world with the inverse transformation
        glRotatef (-pos.roll, 1.0f, 0.0f, 0.0f); 
        glRotatef (-pos.pitch, 0.0f, 1.0f, 0.0f);
        glRotatef (-pos.yaw, 0.0f, 0.0f, 1.0f);
        glTranslatef (-pos.x, -pos.y, -pos.z);
}

void Camera::ComputeInverseView (int time)
{
        Position pos;
        float view[16];

        pos = position->GetPosition (time);

        // retrieve the matrix that corresponds to the viewpoint transformation
        glPushMatrix ();
        glLoadIdentity ();

                glRotatef (90, 0.0f, 1.0f, 0.0f);
                glRotatef (-90, 1.0f, 0.0f, 0.0f);

                glRotatef (-pos.roll, 1.0f, 0.0f, 0.0f); 
                glRotatef (-pos.pitch, 0.0f, 1.0f, 0.0f); 
                glRotatef (-pos.yaw, 0.0f, 0.0f, 1.0f);
                glTranslatef (-pos.x, -pos.y, -pos.z);

                glGetFloatv (GL_MODELVIEW_MATRIX, view);

        glPopMatrix ();

        // and invert it (no problem since a sequence of rotations and translations always yields a
        // homogenous matrix
        Geometry::InvertHomogenousMatrix (view, inverse_view);
}

float * Camera::GetInverseView ()
{
        return inverse_view;
}

void Camera::BuildPlanes (int time)
{
        double res[16];
        double mod[16];

        Position pos;
        pos = position->GetPosition (time);
        
        // set up and retrieve modelview matrix
        glPushMatrix ();
                glLoadIdentity ();

                glRotatef (90, 0.0f, 1.0f, 0.0f);
                glRotatef (-90, 1.0f, 0.0f, 0.0f);

                glRotatef (-pos.roll, 1.0f, 0.0f, 0.0f); 
                glRotatef (-pos.pitch, 0.0f, 1.0f, 0.0f); 
                glRotatef (-pos.yaw, 0.0f, 0.0f, 1.0f); 
                glTranslatef (-pos.x, -pos.y, -pos.z);

                glGetDoublev (GL_MODELVIEW_MATRIX, mod);
        glPopMatrix ();
        
        // set up projection matrix and postmultiply with modelview matrix, retrieve result
        glMatrixMode (GL_PROJECTION);
        glPushMatrix ();
        glLoadIdentity ();
                ApplyAttributes ();
                glMultMatrixd (mod);
                glGetDoublev (GL_PROJECTION_MATRIX, res);
        glPopMatrix ();
        glMatrixMode (GL_MODELVIEW);

        // frustum now transformed to a box...
        front.n.x = res[3] + res[2];
        front.n.y = res[7] + res[6];
        front.n.z = res[11] + res[10];
        front.d = res[15] + res[14];

        back.n.x = res[3] - res[2];
        back.n.y = res[7] - res[6];
        back.n.z = res[11] - res[10];
        back.d = res[15] - res[14];

        left.n.x = res[3] + res[0];
        left.n.y = res[7] + res[4];
        left.n.z = res[11] + res[8];
        left.d = res[15] + res[12];

        right.n.x = res[3] - res[0];
        right.n.y = res[7] - res[4];
        right.n.z = res[11] - res[8];
        right.d = res[15] - res[12];

        bottom.n.x = res[3] + res[1];
        bottom.n.y = res[7] + res[5];
        bottom.n.z = res[11] + res[9];
        bottom.d = res[15] + res[13];

        top.n.x = res[3] - res[1];
        top.n.y = res[7] - res[5];
        top.n.z = res[11] - res[9];
        top.d = res[15] - res[13];

        /* normalize */
        float temp;

        temp = sqrt (front.n.x * front.n.x + front.n.y * front.n.y + front.n.z * front.n.z);
        front.n.x /= temp;
        front.n.y /= temp;
        front.n.z /= temp;
        front.d /= temp;

        temp = sqrt (back.n.x * back.n.x + back.n.y * back.n.y + back.n.z * back.n.z);
        back.n.x /= temp;
        back.n.y /= temp;
        back.n.z /= temp;
        back.d /= temp;

        temp = sqrt (left.n.x * left.n.x + left.n.y * left.n.y + left.n.z * left.n.z);
        left.n.x /= temp;
        left.n.y /= temp;
        left.n.z /= temp;
        left.d /= temp;

        temp = sqrt (right.n.x * right.n.x + right.n.y * right.n.y + right.n.z * right.n.z);
        right.n.x /= temp;
        right.n.y /= temp;
        right.n.z /= temp;
        right.d /= temp;

        temp = sqrt (bottom.n.x * bottom.n.x + bottom.n.y * bottom.n.y + bottom.n.z * bottom.n.z);
        bottom.n.x /= temp;
        bottom.n.y /= temp;
        bottom.n.z /= temp;
        bottom.d /= temp;

        temp = sqrt (top.n.x * top.n.x + top.n.y * top.n.y + top.n.z * top.n.z);
        top.n.x /= temp;
        top.n.y /= temp;
        top.n.z /= temp;
        top.d /= temp;
}

void Camera::DrawFrustum ()
{
        Point corner[8];

        // get the corners of the viewing frustum
        corner[0] = Geometry::PlaneIntersection (front, left, top);
        corner[1] = Geometry::PlaneIntersection (front, left, bottom);
        corner[2] = Geometry::PlaneIntersection (front, right, top);
        corner[3] = Geometry::PlaneIntersection (front, right, bottom);
        corner[4] = Geometry::PlaneIntersection (back, left, top);
        corner[5] = Geometry::PlaneIntersection (back, left, bottom);
        corner[6] = Geometry::PlaneIntersection (back, right, top);
        corner[7] = Geometry::PlaneIntersection (back, right, bottom);

        Utility::SetColor (0.2f, 0.2f, 0.8f, 1.0f);

        // draw front
        Utility::DrawQuad (corner[0], corner[2], corner[3], corner[1]);
        // draw back
        Utility::DrawQuad (corner[6], corner[4], corner[5], corner[7]);
        // draw left
        Utility::DrawQuad (corner[4], corner[0], corner[1], corner[5]);
        // draw right
        Utility::DrawQuad (corner[2], corner[6], corner[7], corner[3]);
        // draw bottom
        Utility::DrawQuad (corner[1], corner[3], corner[7], corner[5]);
        // draw top
        Utility::DrawQuad (corner[4], corner[6], corner[2], corner[0]);
}

void Camera::DrawFrustum2 (int time)
{
        Point corner[8];
        Point c[8];     
        double mod[16];
        double inv[16];

        // retrieve the corners of the frustum from the planes
        corner[0] = Geometry::PlaneIntersection (planes[PLANE_FRONT], planes[PLANE_LEFT], planes[PLANE_TOP]);
        corner[1] = Geometry::PlaneIntersection (planes[PLANE_FRONT], planes[PLANE_LEFT], planes[PLANE_BOTTOM]);
        corner[2] = Geometry::PlaneIntersection (planes[PLANE_FRONT], planes[PLANE_RIGHT], planes[PLANE_TOP]);
        corner[3] = Geometry::PlaneIntersection (planes[PLANE_FRONT], planes[PLANE_RIGHT], planes[PLANE_BOTTOM]);
        corner[4] = Geometry::PlaneIntersection (planes[PLANE_BACK], planes[PLANE_LEFT], planes[PLANE_TOP]);
        corner[5] = Geometry::PlaneIntersection (planes[PLANE_BACK], planes[PLANE_LEFT], planes[PLANE_BOTTOM]);
        corner[6] = Geometry::PlaneIntersection (planes[PLANE_BACK], planes[PLANE_RIGHT], planes[PLANE_TOP]);
        corner[7] = Geometry::PlaneIntersection (planes[PLANE_BACK], planes[PLANE_RIGHT], planes[PLANE_BOTTOM]);

        // but since they are not in our global world coordinates, we have to transform them back manually
        glPushMatrix ();
        glLoadIdentity ();
        
                ApplyPosition (time);
                glGetDoublev (GL_MODELVIEW_MATRIX, mod);

        glPopMatrix ();

        Geometry::InvertHomogenousMatrix (mod, inv);

        c[0].x = corner[0].x * inv[0] + corner[0].y * inv[4] + corner[0].z * inv[8] + inv[12];
        c[0].y = corner[0].x * inv[1] + corner[0].y * inv[5] + corner[0].z * inv[9] + inv[13];
        c[0].z = corner[0].x * inv[2] + corner[0].y * inv[6] + corner[0].z * inv[10] + inv[14];

        c[1].x = corner[1].x * inv[0] + corner[1].y * inv[4] + corner[1].z * inv[8] + inv[12];
        c[1].y = corner[1].x * inv[1] + corner[1].y * inv[5] + corner[1].z * inv[9] + inv[13];
        c[1].z = corner[1].x * inv[2] + corner[1].y * inv[6] + corner[1].z * inv[10] + inv[14];

        c[2].x = corner[2].x * inv[0] + corner[2].y * inv[4] + corner[2].z * inv[8] + inv[12];
        c[2].y = corner[2].x * inv[1] + corner[2].y * inv[5] + corner[2].z * inv[9] + inv[13];
        c[2].z = corner[2].x * inv[2] + corner[2].y * inv[6] + corner[2].z * inv[10] + inv[14];

        c[3].x = corner[3].x * inv[0] + corner[3].y * inv[4] + corner[3].z * inv[8] + inv[12];
        c[3].y = corner[3].x * inv[1] + corner[3].y * inv[5] + corner[3].z * inv[9] + inv[13];
        c[3].z = corner[3].x * inv[2] + corner[3].y * inv[6] + corner[3].z * inv[10] + inv[14];

        c[4].x = corner[4].x * inv[0] + corner[4].y * inv[4] + corner[4].z * inv[8] + inv[12];
        c[4].y = corner[4].x * inv[1] + corner[4].y * inv[5] + corner[4].z * inv[9] + inv[13];
        c[4].z = corner[4].x * inv[2] + corner[4].y * inv[6] + corner[4].z * inv[10] + inv[14];

        c[5].x = corner[5].x * inv[0] + corner[5].y * inv[4] + corner[5].z * inv[8] + inv[12];
        c[5].y = corner[5].x * inv[1] + corner[5].y * inv[5] + corner[5].z * inv[9] + inv[13];
        c[5].z = corner[5].x * inv[2] + corner[5].y * inv[6] + corner[5].z * inv[10] + inv[14];

        c[6].x = corner[6].x * inv[0] + corner[6].y * inv[4] + corner[6].z * inv[8] + inv[12];
        c[6].y = corner[6].x * inv[1] + corner[6].y * inv[5] + corner[6].z * inv[9] + inv[13];
        c[6].z = corner[6].x * inv[2] + corner[6].y * inv[6] + corner[6].z * inv[10] + inv[14];

        c[7].x = corner[7].x * inv[0] + corner[7].y * inv[4] + corner[7].z * inv[8] + inv[12];
        c[7].y = corner[7].x * inv[1] + corner[7].y * inv[5] + corner[7].z * inv[9] + inv[13];
        c[7].z = corner[7].x * inv[2] + corner[7].y * inv[6] + corner[7].z * inv[10] + inv[14];

        Utility::SetColor (0.2f, 0.2f, 0.8f, 1.0f);

        Utility::DrawQuad (c[0], c[2], c[3], c[1]);
        Utility::DrawQuad (c[6], c[4], c[5], c[7]);
        Utility::DrawQuad (c[4], c[0], c[1], c[5]);
        Utility::DrawQuad (c[2], c[6], c[7], c[3]);
        Utility::DrawQuad (c[1], c[3], c[7], c[5]);
        Utility::DrawQuad (c[4], c[6], c[2], c[0]);
}

void Camera::BuildPlanes2 ()
{
        double pro[16];
        
        glMatrixMode (GL_PROJECTION);
        glPushMatrix ();
        glLoadIdentity ();
                ApplyAttributes ();
                glGetDoublev (GL_PROJECTION_MATRIX, pro);
        glPopMatrix ();
        glMatrixMode (GL_MODELVIEW);

        // frustum now transformed to a box...
        planes[PLANE_FRONT].n.x = pro[3] + pro[2];
        planes[PLANE_FRONT].n.y = pro[7] + pro[6];
        planes[PLANE_FRONT].n.z = pro[11] + pro[10];
        planes[PLANE_FRONT].d = pro[15] + pro[14];

        planes[PLANE_BACK].n.x = pro[3] - pro[2];
        planes[PLANE_BACK].n.y = pro[7] - pro[6];
        planes[PLANE_BACK].n.z = pro[11] - pro[10];
        planes[PLANE_BACK].d = pro[15] - pro[14];

        planes[PLANE_LEFT].n.x = pro[3] + pro[0];
        planes[PLANE_LEFT].n.y = pro[7] + pro[4];
        planes[PLANE_LEFT].n.z = pro[11] + pro[8];
        planes[PLANE_LEFT].d = pro[15] + pro[12];

        planes[PLANE_RIGHT].n.x = pro[3] - pro[0];
        planes[PLANE_RIGHT].n.y = pro[7] - pro[4];
        planes[PLANE_RIGHT].n.z = pro[11] - pro[8];
        planes[PLANE_RIGHT].d = pro[15] - pro[12];

        planes[PLANE_BOTTOM].n.x = pro[3] + pro[1];
        planes[PLANE_BOTTOM].n.y = pro[7] + pro[5];
        planes[PLANE_BOTTOM].n.z = pro[11] + pro[9];
        planes[PLANE_BOTTOM].d = pro[15] + pro[13];

        planes[PLANE_TOP].n.x = pro[3] - pro[1];
        planes[PLANE_TOP].n.y = pro[7] - pro[5];
        planes[PLANE_TOP].n.z = pro[11] - pro[9];
        planes[PLANE_TOP].d = pro[15] - pro[13];

        /* normalize */
        for (int index = 0; index < 6; index++)
        {
                float temp;

                temp = sqrt (planes[index].n.x * planes[index].n.x + planes[index].n.y * planes[index].n.y + planes[index].n.z * planes[index].n.z);
                planes[index].n.x /= temp;
                planes[index].n.y /= temp;
                planes[index].n.z /= temp;
                planes[index].d /= temp;
        }
}

void Camera::MoveForward (double amount)
{
        Position p;
        Vector delta;

        p = position->GetPosition (0);

        delta.x = cos(DEG2RAD(p.pitch)) * cos (DEG2RAD(p.yaw)) * amount;
        delta.y = cos(DEG2RAD(p.pitch)) * sin (DEG2RAD(p.yaw)) * amount;
        delta.z = - sin (DEG2RAD(p.pitch)) * amount;

        position->SetConstantPosition (p.x + delta.x, p.y + delta.y , p.z + delta.z, p.roll, p.pitch, p.yaw);
}

void Camera::MoveRight (double amount)
{
        Position p;
        Vector delta;

        p = position->GetPosition (0);

        delta.x = (-cos(DEG2RAD(p.roll))*sin(DEG2RAD(p.yaw)) + sin(DEG2RAD(p.roll))*sin(DEG2RAD(p.pitch))*cos(DEG2RAD(p.yaw))) * amount;
        delta.y = (sin(DEG2RAD(p.roll))*sin(DEG2RAD(p.pitch))*sin(DEG2RAD(p.yaw)) + cos(DEG2RAD(p.roll))*cos(DEG2RAD(p.yaw))) * amount;
        delta.z = sin(DEG2RAD(p.roll))*cos(DEG2RAD(p.pitch))*amount;

        position->SetConstantPosition (p.x + delta.x, p.y + delta.y, p.z + delta.z, p.roll, p.pitch, p.yaw);
}

void Camera::MoveUp (double amount)
{
        Position p;
        Vector delta;

        p = position->GetPosition (0);

        delta.x = (cos(DEG2RAD(p.roll))*sin(DEG2RAD(p.pitch))*cos(DEG2RAD(p.yaw)) + sin(DEG2RAD (p.roll))*sin(DEG2RAD(p.yaw))) * amount;
        delta.y = (-sin(DEG2RAD(p.roll))*cos(DEG2RAD(p.yaw)) + cos(DEG2RAD(p.roll))*sin(DEG2RAD(p.pitch))*sin(DEG2RAD(p.yaw))) * amount;
        delta.z = cos(DEG2RAD(p.roll))* cos(DEG2RAD(p.pitch)) * amount;

        position->SetConstantPosition (p.x + delta.x, p.y + delta.y, p.z + delta.z, p.roll, p.pitch, p.yaw);
}

---