K3dCamera.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "K3dCamera.h"
#include <SDL/SDL.h>

K3dCamera::K3dCamera(K3dGameData *_pGameData)
{
        m_pGameData = _pGameData;
        m_pVector3Work = m_pGameData->GetVector3Work();
        Init();
}

K3dCamera::~K3dCamera()         
{
}


void K3dCamera::Init()
{
        // Default camera speed
        m_fSpeed = 10;
        // Default camera acceleration
        m_fSpeedAccel = 150;
        
        // Set alternation anle and position
        K3dVector3 angleAlter(0,0,0);
        K3dVector3 posAlter(0,0,0);
        // Set up vector
        m_kUp.Set(0,1,0);       
        m_bIsMouseMove = false;
        // Set view vector
        m_kView.Set(0,0,-1);

        // Get gloabl graphics options
        TGraphicOption *pOptions = m_pGameData->GetGraphicOption();
        // Set middle of screen
        int aiMiddle[2];
        aiMiddle[0] = pOptions->iWidth  >> 1;
        aiMiddle[1] = pOptions->iHeight >> 1;
        // Move mouse cursor to the middle of screen
        SDL_WarpMouse(aiMiddle[0], aiMiddle[1]);
}

void K3dCamera::UpdateCamera()
{
        // Get global timer
        K3dTimer *pTimer = m_pGameData->GetTimer();
        // Synchronize camera speed
        m_fSpeed = m_fSpeedAccel;
        pTimer->SynchronizeSpeed(m_fSpeed);
        // Move with camera by mouse
        if(m_bIsMouseMove)
        {
                MouseRotate();
        }

        // Get global keyboard map pointer
        K3dKeyMap *pKeyMap = m_pGameData->GetKeyMap();  

        if(pKeyMap->IsKeyPressed(K_GO_FORWARD))
        {
                GoForward();
        }
        if(pKeyMap->IsKeyPressed(K_GO_BACKWARD))
        {
                GoBackward();
        }
        if(pKeyMap->IsKeyPressed(K_TURN_LEFT))
        {
                TurnLeft();
        }
        if(pKeyMap->IsKeyPressed(K_TURN_RIGHT))
        {
                TurnRight();
        }
        if(pKeyMap->IsKeyPressed(K_STRAFE_RIGHT))
        {
                StrafeRight();
        }
        if(pKeyMap->IsKeyPressed(K_STRAFE_LEFT))
        {
                StrafeLeft();
        }
        if(pKeyMap->IsKeyPressed(K_GO_UP))
        {
                GoUp();
        }
        if(pKeyMap->IsKeyPressed(K_GO_DOWN))
        {
                GoDown();
        }
        if(pKeyMap->IsKeyPressed(K_LURCH_LEFT))
        {
                LurchLeft();
        }
        if(pKeyMap->IsKeyPressed(K_LURCH_RIGHT))
        {
                LurchRight();
        }
        if(pKeyMap->IsKeyPressed(K_TURN_UP))
        {
                TurnUp();
        }
        if(pKeyMap->IsKeyPressed(K_TURN_DOWN))
        {
                TurnDown();
        }

        ChangeMatrix(); 
}

K3dVector3Obj& K3dCamera::GetPosition()
{
    return m_kPosition;
}
const K3dVector3Obj& K3dCamera::GetPosition() const
{
    return m_kPosition;
}

K3dVector3Obj& K3dCamera::GetForward()
{
    return m_kForward;
}

const K3dVector3Obj& K3dCamera::GetForward() const
{
    return m_kForward;
}

K3dVector3Obj& K3dCamera::GetUp()
{
        return m_kUp;
}
const K3dVector3Obj& K3dCamera::GetUp() const
{
        return m_kUp;
}

K3dVector3Obj& K3dCamera::GetRight()
{
        return m_kRight;
}
const K3dVector3Obj& K3dCamera::GetRight() const
{
        return m_kRight;
}

K3dMatrix& K3dCamera::GetRotMatrix()
{
        return m_kRotMatrix;
}
const K3dMatrix& K3dCamera::GetRotMatrix() const
{
        return m_kRotMatrix;
}

K3dMatrix& K3dCamera::GetMatrix()
{
        return m_kMatrix;
}
const K3dMatrix& K3dCamera::GetMatrix() const
{
        return m_kMatrix;
}

K3dMatrix& K3dCamera::GetPrevMatrix()
{
        return m_kPrevMatrix;
}
const K3dMatrix& K3dCamera::GetPrevMatrix() const
{
        return m_kPrevMatrix;
}

void K3dCamera::Move(const float _fSpeed )
{       
        // If spectator view
        if(m_eCamView == K_CAM_SPECTATE) 
        {
                m_pVector3Work->SubtractScalar(m_kPosition, _fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->SubtractScalar(m_kPosition, _fSpeed * m_kForward.GetScalar(1) ,1);
                m_pVector3Work->AddScalar(m_kPosition, _fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
        // If first person view
        if(m_eCamView == K_CAM_FIRST_PERSON)
        {
                m_pVector3Work->SubtractScalar(m_kPosition, _fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->AddScalar(m_kPosition, _fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
}

void K3dCamera::RestrictCamView()
{
        if ( m_kAngle[0] >= K3dMath::K_FI )
        {
                m_kAngle[0] = K3dMath::K_FI;
        }
        
        if ( m_kAngle[0] <= -K3dMath::K_FI )
        {
                m_kAngle[0] = -K3dMath::K_FI;
        }
}

void K3dCamera::MouseRotate()
{       
        // Get global graphics options
        TGraphicOption *pOptions = m_pGameData->GetGraphicOption();
        
        // Set middle of screen
        int aiMiddle[2];
        aiMiddle[0] = pOptions->iWidth  >> 1;
        aiMiddle[1] = pOptions->iHeight >> 1;
        
        // Get current mouse cursor position
        int aiPos[2];
        aiPos[0] = m_pGameData->GetMouse()->MousePosition()[0];
        aiPos[1] = m_pGameData->GetMouse()->MousePosition()[1];
        
        // Calculate mouse step
        int aiStep[2];
        aiStep[0] = (aiPos[0] - aiMiddle[0]);
        aiStep[1] = (aiPos[1] - aiMiddle[1]);

        // Change rotation angles by mouse step
        m_pVector3Work->AddScalar(m_kAngle, (float)aiStep[0]*0.01 ,1);
        m_pVector3Work->AddScalar(m_kAngle, (float)aiStep[1]*0.01 ,0);
        
        // Move mouse cursor to the middle of screen
        SDL_WarpMouse(aiMiddle[0], aiMiddle[1]);

        // If spectator or first person view than restric camera view
        if((m_eCamView == K_CAM_FIRST_PERSON) || (m_eCamView == K_CAM_SPECTATE))
        {
                RestrictCamView();
        }
}

void K3dCamera::GoForward()
{
        // If descent camera
        if(m_eCamView == K_CAM_DESCENT)
        {       
                // Change currect position by forward vector
                m_kPosition += (m_kForward * m_fSpeed);
                return;
        }
        // If first person camera
        if(m_eCamView == K_CAM_FIRST_PERSON)
        {
                m_pVector3Work->SubtractScalar(m_kPosition, m_fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->AddScalar(m_kPosition, m_fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
        // If spectate camera
        if(m_eCamView == K_CAM_SPECTATE)
        {
                m_pVector3Work->SubtractScalar(m_kPosition, m_fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->SubtractScalar(m_kPosition, m_fSpeed * m_kForward.GetScalar(1) ,1);
                m_pVector3Work->AddScalar(m_kPosition, m_fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
}

void K3dCamera::GoBackward()
{
        // If descent camera
        if(m_eCamView == K_CAM_DESCENT)
        {       
                // Change currect position by right vector
                m_kPosition -= (m_kForward * m_fSpeed);
                return;
        }
        // If first person camera
        if(m_eCamView == K_CAM_FIRST_PERSON)
        {
                m_pVector3Work->SubtractScalar(m_kPosition, -m_fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->AddScalar(m_kPosition, -m_fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
        // If spectate camera
        if(m_eCamView == K_CAM_SPECTATE)
        {
                m_pVector3Work->SubtractScalar(m_kPosition, -m_fSpeed * m_kForward.GetScalar(0) ,0);
                m_pVector3Work->SubtractScalar(m_kPosition, -m_fSpeed * m_kForward.GetScalar(1) ,1);
                m_pVector3Work->AddScalar(m_kPosition, -m_fSpeed * m_kForward.GetScalar(2) ,2);
                return;
        }
}

void K3dCamera::GoUp()
{
        // If descent camera
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Change currect position by up vector
                m_kPosition += m_kUp * m_fSpeed;
        }
        else
        {
                m_pVector3Work->AddScalar(m_kPosition, m_fSpeed ,1);
        }
}

void K3dCamera::GoDown()
{
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Change currect position by up vector
                m_kPosition -= m_kUp * m_fSpeed;
        }
        else
        {
                m_pVector3Work->SubtractScalar(m_kPosition, m_fSpeed ,1);
        }
}

void K3dCamera::SetStrafeDirection()
{
                K3dVector3 kDirection;
                        
                // Slave matrixes (reset)
                K3dMatrix kM;
                K3dMatrix kMX;
                K3dMatrix kMY;
                
                // Set X rotation matrix 
                kMX.RotationXGL(m_kAngle[0]);
                // Set Y rotation matrix
                kMY.RotationYGL(m_kAngle[1]);
                
                // Set X direction
                // Hold mX matrix
                kM = kMX;
                // Multiply by matrix mY
                kM.MultiplyTranspose(kMY);
                // Reset direction vector
                kDirection.Set(1,0,0);
                // Change coordination X in direction vector
                kM.ChangeVectorXGL(kDirection);
                // Set X coord to my direction
                m_kForward.SetX(kDirection[0]);
                
                // Set Y direction
                m_kForward.SetY(0);
                
                // Set Z direction
                // Reset direction vector
                kDirection.Set(1,0,0);
                // Change coordination X in direction vector
                kM.ChangeVectorZGL(kDirection);
                // Set Z coord to my direction
                m_kForward.SetZ(kDirection[2]);
}

void K3dCamera::StrafeLeft()
{
        // If descent camera
        if(m_eCamView == K_CAM_DESCENT)
        {       
                // Change currect position by right vector
                m_kPosition -= (m_kRight * m_fSpeed);
        }
        else
        {
                SetStrafeDirection();
                // Move by new direction
                Move(m_fSpeed);
        }
}

void K3dCamera::StrafeRight()
{
        // If descent camera
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Change currect position by right vector
                m_kPosition += m_kRight * m_fSpeed;
        }
        else
        {
                SetStrafeDirection();
                // Move by new direction
                Move(-m_fSpeed);
        }
}

void K3dCamera::TurnLeft()
{
        m_pVector3Work->SubtractScalar(m_kAngle, m_fSpeed* 0.01f ,1);
}

void K3dCamera::TurnRight()
{
        m_pVector3Work->AddScalar(m_kAngle, m_fSpeed* 0.01f ,1);
}


void K3dCamera::TurnUp()                
{
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Set angles
                m_pVector3Work->AddScalar(m_kAngle, m_fSpeed * 0.01f ,0);
        }
        else
        {
                m_pVector3Work->AddScalar(m_kAngle, m_fSpeed * 0.01f ,0);
                // If spectator or first person view than restric camera view
                RestrictCamView();
        }
}

void K3dCamera::TurnDown()              
{
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Set angles
                m_pVector3Work->SubtractScalar(m_kAngle, m_fSpeed  * 0.01f ,0);
        }
        else
        {       
                m_pVector3Work->SubtractScalar(m_kAngle, m_fSpeed  * 0.01f ,0);
                // If spectator or first person view than restric camera view
                RestrictCamView();
        }
}

void K3dCamera::LurchLeft()
{
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Set angles
                m_pVector3Work->SubtractScalar(m_kAngle, m_fSpeed * 0.01f ,2);
        }
}

void K3dCamera::LurchRight()
{
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Set angle
                m_pVector3Work->AddScalar(m_kAngle, m_fSpeed * 0.01f ,2);
        }
}

void K3dCamera::Look()
{
        // Load OpenGL model matrix from camera matrix
        glLoadMatrixf(m_kMatrix.GetMatrix());
}

void K3dCamera::ChangeMatrix()
{
        // If descent view
        if(m_eCamView == K_CAM_DESCENT)
        {
                // Slave matrices (reset)
                K3dMatrix kT;
                K3dMatrix kR;
                // Set quaternion from angle
                K3dQuaternion kQuat;
                kQuat.FromAxisAngle(m_kAngle);
                // Set rotation matrix from quaternion
                kQuat.ToRotationMatrix(kR);
                // Copy rotation to camera matrix
                m_kMatrix = kR;
                // Multiply previous matrix by new matrix
                m_kMatrix.Multiply(m_kPrevMatrix);
                // Set rotation matrix from current matrix
                m_kRotMatrix = m_kMatrix;
                // Inverse rotation matrix
                m_kRotMatrix.Inverse();
                // Set direction vector
                m_kForward.Set(0,0,-1);
                // Change direction vector by rotation matrix
                m_kRotMatrix.ChangeVectorGL(m_kForward);
                // Set up vector
                m_kUp.Set(0,1,0);
                // Change up vector by rotation matrix
                m_kRotMatrix.ChangeVectorGL(m_kUp);
                // Set right vector
                m_kRight.Set(1,0,0);
                // Change right vector by rotation matrix
                m_kRotMatrix.ChangeVectorGL(m_kRight);
                // Store current matrix to previous matrix
                m_kPrevMatrix = m_kMatrix;
                // Set inverse matrix from current position 
                kT.InverseTranslation(m_kPosition);
                // Multiply inverse matrix and current position matrix
                m_kMatrix.Multiply(kT);
                // Reset angles
                m_kAngle.Reset();
                
                // Set view vector
                m_kView.Set(0,0,-1);
                m_kMatrix.ChangeVector(m_kView);
                return;
        }

        // If spectator or first person view
        if((m_eCamView == K_CAM_SPECTATE)||(m_eCamView == K_CAM_FIRST_PERSON))
        {
                // Slave direction vector
                K3dVector3 kDirection;
                // Right vector
                K3dVector3 kRight;
                // Slave matrices (reset)
                K3dMatrix kMX;
                K3dMatrix kMY;
                K3dMatrix kMT;

                // Set X rotation matrix 
                kMX.RotationXGL(m_kAngle[0]);
                // Set Y rotation matrix
                kMY.RotationYGL(m_kAngle[1]);
                // Set inverse translation matrix
                kMT.InverseTranslation(m_kPosition);

                // Set Z direction
                // Reset direction vector
                kDirection.Set(0,0,-1);
                kMY.ChangeVectorZGL(kDirection);
                // Set Z coord to my direction
                m_kForward.SetZ(kDirection[2]);
        
                // Only if spectate view
                if(m_eCamView == K_CAM_SPECTATE)
                {
                        // Set Y direction
                        // Reset direction vector
                        kDirection.Set(0,0,-1);
                        kMX.ChangeVectorYGL(kDirection);
                        // Set Z coord to my direction
                        m_kForward.SetY(kDirection[1]);
                }
                // Calculate camera matrix
                // Copy slave matrix Y to camera matrix
                m_kMatrix = kMY;
                // Multiply by slave matrix X
                m_kMatrix.MultiplyTranspose(kMX);
                // Multiply by slave transform matrix Y
                m_kMatrix.Multiply(kMT);

                // Set X direction
                // Reset direction vector
                kDirection.Set(0,0,-1);
                // Change coordination X in direction vector
                m_kMatrix.ChangeVectorXGL(kDirection);
                // Set X coord to my direction
                m_kForward.SetX(kDirection[0]);

                // Set view vector
                m_kView.Set(0,0,-1);
                m_kMatrix.ChangeVector(m_kView);
                // Set right vector
                m_kRight.Set(1,0,0);
                // Change right vector by rotation matrix
                m_kMatrix.ChangeVector(m_kRight);
                // Set up vector
                m_kUp.Set(0,1,0);
                // Change up vector by rotation matrix
                m_kMatrix.ChangeVector(m_kUp);

                return;
        }
}

---