Camera.cpp

Go to the documentation of this file.

#include "Camera.h"

Camera::Camera() {
        //m_maxPitchRate                = 0.0f;
        //m_maxHeadingRate              = 0.0f;
        m_headingDegrees                = 0.0f;
        m_pitchDegrees                  = 0.0f;
        //m_maxForwardVelocity  = 0.0f;
        //m_forwardVelocity             = 0.0f;
        m_shakeTime                             = 0.0f;
        m_shakeIntensity                = 0.0f;
        isMoved = false;
}

Camera::~Camera() {
}

void Camera::setPrespective(float dTime, bool movePos) {
        if (!isMoved) {
                float matrix[16];
                Quaternion q;

                m_pitch.createFromAxisAngle(1.0f, 0.0f, 0.0f, m_pitchDegrees);
                m_heading.createFromAxisAngle(0.0f, 1.0f, 0.0f, m_headingDegrees);

                q = m_pitch * m_heading;
                q.createMatrix(matrix);

                glMultMatrixf(matrix);  // OGL

                m_pitch.createMatrix(matrix);
                m_direction.y = matrix[9];

                m_strafe.y = matrix[1];
                m_up.y = matrix[5];

                q = m_heading*m_pitch;
                q.createMatrix(matrix);
                m_direction.x = matrix[8];
                m_direction.z = matrix[10];

                m_strafe.x = matrix[0];
                m_strafe.z = matrix[2];

                m_up.x = matrix[4];
                m_up.z = matrix[6];

                isMoved = true;
        }

        if (movePos)
                setPos(dTime);
}

void Camera::setPos(float dTime) {
        if (m_shakeTime > 0.0f) {
                Vec3 offset;
                offset.x += sinf(m_shakeTime*m_shakeSpeed)*cosf(m_shakeTime*m_shakeSpeed)*m_shakeIntensity*m_shakeTime;
                offset.y += cosf(m_shakeTime*m_shakeSpeed)*m_shakeIntensity*m_shakeTime;
                offset.z += cosf(m_shakeTime*m_shakeSpeed)*m_shakeIntensity*m_shakeTime;
                m_shakeTime -= dTime;

                glTranslatef(-m_position.x+offset.x, -m_position.y+offset.y, m_position.z+offset.z);    // OGL
        }
        else
                glTranslatef(-m_position.x, -m_position.y, m_position.z);       // OGL

        isMoved = false;
}

void Camera::setProjection(float angle, int width, int height, float n, float f) {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective (angle, (GLfloat)(width)/(GLfloat)(height), n, f);
        glMatrixMode(GL_MODELVIEW);
        //glLoadIdentity();
}

void Camera::changePitch(float degrees) {
        m_pitchDegrees += degrees;

        if (m_pitchDegrees > 360.0f)
                m_pitchDegrees -= 360.0f;
        else if (m_pitchDegrees < -360.0f)
                m_pitchDegrees += 360.0f;
}

void Camera::setPitch(float degrees) {
        m_pitchDegrees = degrees;
}

void Camera::changeHeading(float degrees) {
        if (m_pitchDegrees > 90.0f && m_pitchDegrees < 270.0f || (m_pitchDegrees < -90.0f && m_pitchDegrees > -270.0f))
                m_headingDegrees -=degrees;
        else
                m_headingDegrees += degrees;

        if (m_headingDegrees > 360.0f)
                m_headingDegrees -= 360.0f;
        else if (m_headingDegrees < -360.0f)
                m_headingDegrees += 360.0f;
}

void Camera::setHeading(float degrees) {
        m_headingDegrees = degrees;
}


void Camera::moveForward(float val) {
        m_position += m_direction*val;
}

void Camera::strafeRight(float val) {
        m_position += m_strafe*val;
}

void Camera::moveUp(float val) {
        m_position += m_up*val;
}

void Camera::setPosition(Vec3 position) {
        m_position = Vec3(position.x, position.y, -position.z);
}

Vec3 Camera::getPosition() {
        return Vec3(m_position.x, m_position.y, -m_position.z); //m_position;
}

void Camera::shake(float time, float speed, float intensity) {
        m_shakeTime += time;
        m_shakeSpeed = speed;
        m_shakeIntensity = intensity;
}

void Camera::updateFrustum() {
   GLfloat clip[16];
   GLfloat proj[16];
   GLfloat modl[16];
   GLfloat t;

   // Get The Current PROJECTION Matrix From OpenGL
   glGetFloatv( GL_PROJECTION_MATRIX, proj );

   // Get The Current MODELVIEW Matrix From OpenGL
   glGetFloatv( GL_MODELVIEW_MATRIX, modl );

   // Combine The Two Matrices (Multiply Projection By Modelview) 
   // But Keep In Mind This Function Will Only Work If You Do NOT
   // Rotate Or Translate Your Projection Matrix
   clip[ 0] = modl[ 0] * proj[ 0];
   clip[ 1] = modl[ 1] * proj[ 5];
   clip[ 2] = modl[ 2] * proj[10] + modl[ 3] * proj[14];
   clip[ 3] = modl[ 2] * proj[11];

   clip[ 4] = modl[ 4] * proj[ 0];
   clip[ 5] = modl[ 5] * proj[ 5];
   clip[ 6] = modl[ 6] * proj[10] + modl[ 7] * proj[14];
   clip[ 7] = modl[ 6] * proj[11];

   clip[ 8] = modl[ 8] * proj[ 0];
   clip[ 9] = modl[ 9] * proj[ 5];
   clip[10] = modl[10] * proj[10] + modl[11] * proj[14];
   clip[11] = modl[10] * proj[11];

   clip[12] = modl[12] * proj[ 0];
   clip[13] = modl[13] * proj[ 5];
   clip[14] = modl[14] * proj[10] + modl[15] * proj[14];
   clip[15] = modl[14] * proj[11];

   // Extract The Numbers For The RIGHT Plane
   m_Frustum[0][0] = clip[ 3] - clip[ 0];
   m_Frustum[0][1] = clip[ 7] - clip[ 4];
   m_Frustum[0][2] = clip[11] - clip[ 8];
   m_Frustum[0][3] = clip[15] - clip[12];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[0][0] * m_Frustum[0][0] + m_Frustum[0][1] * m_Frustum[0][1]   
   + m_Frustum[0][2] * m_Frustum[0][2] ));
   m_Frustum[0][0] /= t;
   m_Frustum[0][1] /= t;
   m_Frustum[0][2] /= t;
   m_Frustum[0][3] /= t;

   // Extract The Numbers For The LEFT Plane
   m_Frustum[1][0] = clip[ 3] + clip[ 0];
   m_Frustum[1][1] = clip[ 7] + clip[ 4];
   m_Frustum[1][2] = clip[11] + clip[ 8];
   m_Frustum[1][3] = clip[15] + clip[12];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[1][0] * m_Frustum[1][0] + m_Frustum[1][1] * m_Frustum[1][1]  
   + m_Frustum[1][2] * m_Frustum[1][2] ));
   m_Frustum[1][0] /= t;
   m_Frustum[1][1] /= t;
   m_Frustum[1][2] /= t;
   m_Frustum[1][3] /= t;

   // Extract The BOTTOM Plane
   m_Frustum[2][0] = clip[ 3] + clip[ 1];
   m_Frustum[2][1] = clip[ 7] + clip[ 5];
   m_Frustum[2][2] = clip[11] + clip[ 9];
   m_Frustum[2][3] = clip[15] + clip[13];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[2][0] * m_Frustum[2][0] + m_Frustum[2][1] * m_Frustum[2][1]   
   + m_Frustum[2][2] * m_Frustum[2][2] ));
   m_Frustum[2][0] /= t;
   m_Frustum[2][1] /= t;
   m_Frustum[2][2] /= t;
   m_Frustum[2][3] /= t;

   // Extract The TOP Plane
   m_Frustum[3][0] = clip[ 3] - clip[ 1];
   m_Frustum[3][1] = clip[ 7] - clip[ 5];
   m_Frustum[3][2] = clip[11] - clip[ 9];
   m_Frustum[3][3] = clip[15] - clip[13];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[3][0] * m_Frustum[3][0] + m_Frustum[3][1] * m_Frustum[3][1]   
   + m_Frustum[3][2] * m_Frustum[3][2] ));
   m_Frustum[3][0] /= t;
   m_Frustum[3][1] /= t;
   m_Frustum[3][2] /= t;
   m_Frustum[3][3] /= t;

   // Extract The FAR Plane
   m_Frustum[4][0] = clip[ 3] - clip[ 2];
   m_Frustum[4][1] = clip[ 7] - clip[ 6];
   m_Frustum[4][2] = clip[11] - clip[10];
   m_Frustum[4][3] = clip[15] - clip[14];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[4][0] * m_Frustum[4][0] + m_Frustum[4][1] * m_Frustum[4][1]   
   + m_Frustum[4][2] * m_Frustum[4][2] ));
   m_Frustum[4][0] /= t;
   m_Frustum[4][1] /= t;
   m_Frustum[4][2] /= t;
   m_Frustum[4][3] /= t;

   // Extract The NEAR Plane
   m_Frustum[5][0] = clip[ 3] + clip[ 2];
   m_Frustum[5][1] = clip[ 7] + clip[ 6];
   m_Frustum[5][2] = clip[11] + clip[10];
   m_Frustum[5][3] = clip[15] + clip[14];

   // Normalize The Result
   t = GLfloat(sqrt( m_Frustum[5][0] * m_Frustum[5][0] + m_Frustum[5][1] * m_Frustum[5][1]  
   + m_Frustum[5][2] * m_Frustum[5][2] ));
   m_Frustum[5][0] /= t;
   m_Frustum[5][1] /= t;
   m_Frustum[5][2] /= t;
   m_Frustum[5][3] /= t;
}

bool Camera::sphereInFrustum(Vec3 pos, float r) {
        for (int i = 0; i < 6; i++) {
                if (m_Frustum[i][0] * pos.x + m_Frustum[i][1] * pos.y + m_Frustum[i][2] * pos.z + m_Frustum[i][3] <= -r) {
                        return false;
                }
        }
        return true;
}

---