D:/Zythum/DinoKod/Render/Camera.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Camera.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Assert.h"
#include "Common/types.h"
#include "Common/Console.h"
#include "Common/Plane.h"

#include "Render/Camera.h"

#include <math.h>

//--------------------------------------------------------------------------------------------------------------------------------
KCamera::KCamera( float Fov, float Aspect, float Near, float Far )
{
        SetParam( Fov, Aspect, Near, Far );
        
        m_Matrix.LoadIdentity();
        m_fYaw          = 0.0f;
        m_fPitch        = PI / 2.0f;
        m_Pos           = KVector( 0.0f, 0.0f, 0.0f );
}

//--------------------------------------------------------------------------------------------------------------------------------
KCamera::~KCamera()
{
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::SetParam( float Fov, float Aspect, float Near, float Far )
{
        m_Fov           = Fov;
        m_Aspect        = Aspect;
        m_Near          = Near;
        m_Far           = Far;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::Reset()
{
        m_Matrix.LoadIdentity();
        m_fYaw          = 0.0f;
        m_fPitch        = PI / 2.0f;
        m_Pos           = KVector( 0.0f, 0.0f, 0.0f );

        ComputeMatrix();
//      Translate( 0.0f, 0.0f, 0.0f );
}

//--------------------------------------------------------------------------------------------------------------------------------
KMatrix KCamera::GetMatrix()
{
/*      KMatrix         Matrix;
        KMatrix         Mat;
        float           cosine;
        float           sine;

        Matrix.LoadIdentity();
        
        // Pos
        Matrix._41      = m_Pos.x;
        Matrix._42      = m_Pos.y;
        Matrix._43      = m_Pos.z;

        // Yaw
        cosine  = (float)cos( -m_fYaw );
        sine    = (float)sin( -m_fYaw );

        Mat.LoadIdentity();
        Mat._11 = cosine;
        Mat._12 = -sine;
        Mat._21 = sine;
        Mat._22 = cosine;
        
        Matrix *= Mat;

        // Pitch
        cosine  = (float)cos( m_fPitch );
        sine    = (float)sin( m_fPitch );

        Mat.LoadIdentity();
        Mat._22 = cosine;
        Mat._23 = sine;
        Mat._32 = -sine;
        Mat._33 = cosine;

        Matrix *= Mat;
*/
        return m_Matrix;
}
/*
//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::ComputeMatrix()
{
        m_Matrix.LoadIdentity();
        
        m_Matrix._41    = m_Pos.x;
        m_Matrix._42    = m_Pos.y;
        m_Matrix._43    = m_Pos.z;
/*      
        n.x     = (float)(sin( m_fPitch ) * cos( m_fYaw ) );
        n.y     = (float)(sin( m_fPitch ) * sin( m_fYaw ) );
        n.z     = (float)cos( m_fPitch );
        
        v = vUp - KVector::CrossProduct( ( KVector::CrossProduct( n, vUp ) ), n );
        u = n * v;
        
        m_Matrix._11    = u.x;
        m_Matrix._12    = u.y;
        m_Matrix._13    = u.z;

        m_Matrix._21    = v.x;
        m_Matrix._22    = v.y;
        m_Matrix._23    = v.z;

        m_Matrix._31    = n.x;
        m_Matrix._32    = n.y;
        m_Matrix._33    = n.z;
*/
/*      // Pos
        m_Matrix._41    = m_Pos.x;
        m_Matrix._42    = m_Pos.y;
        m_Matrix._43    = m_Pos.z;

        RotY( -m_fYaw );
        RotX( m_fPitch );

}*/

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotX( float ang )
{
        KMatrix         Mat;
        float           cosine;
        float           sine;

        cosine  = (float)cos( ang );
        sine    = (float)sin( ang );

        Mat.LoadIdentity();
        Mat._22 = cosine;
        Mat._23 = sine;
        Mat._32 = -sine;
        Mat._33 = cosine;

        m_Matrix *= Mat;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotY( float ang )
{
        KMatrix         Mat;
        float           cosine;
        float           sine;

        cosine  = (float)cos( ang );
        sine    = (float)sin( ang );

        Mat.LoadIdentity();
        Mat._11 = cosine;
        Mat._13 = sine;
        Mat._31 = -sine;
        Mat._33 = cosine;
        
        m_Matrix *= Mat;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotZ( float ang )
{
        KMatrix         Mat;
        float           cosine;
        float           sine;

        cosine  = (float)cos( ang );
        sine    = (float)sin( ang );

        Mat.LoadIdentity();
        Mat._11 = cosine;
        Mat._12 = -sine;
        Mat._21 = sine;
        Mat._22 = cosine;
        
        m_Matrix *= Mat;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::ComputeLookAtMatrix()
{
/*      KMatrix matrix;
        KVector view;
        KVector right;
        KVector up;
        
        view    = m_TargetPos - m_CameraPos;
        view.Normalize();
        
    right       = KVector::CrossProduct( KVector( 1.0f, 0.0f, 0.0f ), view );
        up              = KVector::CrossProduct( view, right );

        right.Normalize();
        up.Normalize();

        matrix.LoadIdentity();

    matrix._11 = right.x;  matrix._12 = up.x;  matrix._13 = view.x;
    matrix._21 = right.y;  matrix._22 = up.y;  matrix._23 = view.y;
    matrix._31 = right.z;  matrix._32 = up.z;  matrix._33 = view.z;

    matrix._41 = - KVector::DotProduct( right, m_CameraPos );
    matrix._42 = - KVector::DotProduct( up, m_CameraPos );
    matrix._43 = - KVector::DotProduct( view, m_CameraPos );

        m_Matrix = matrix;*/
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::SetTargetPosition( float x, float y, float z )
{
        m_Target.LoadIdentity();
        m_Target._41 = x;
        m_Target._42 = y;
        m_Target._43 = z;

        m_TargetRot.LoadIdentity();
        m_TargetRot._41 = x;
        m_TargetRot._42 = y;
        m_TargetRot._42 = z;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::SetCameraPosition( float x, float y, float z )
{
        m_CameraPos.x = x;
        m_CameraPos.y = y;
        m_CameraPos.z = z;
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotateX( float ang )
{
        m_fPitch += ang;

        ComputeMatrix();
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotateY( float ang )
{
        ComputeMatrix();
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::RotateZ( float ang )
{
        m_fYaw += ang;
        
        ComputeMatrix();
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::Translate( float x, float y, float z )
{
        KVector         vUp;
        KVector         vRight;
        KVector         vView;

        GetAxes( vRight, vUp, vView );

        vRight.Normalize();
        vRight  *= x;
        vUp.Normalize();
        vUp             *= y;
        vView.Normalize();
        vView   *= z;

        m_Pos   = m_Pos + vUp + vRight + vView;

        ComputeMatrix();
}

//--------------------------------------------------------------------------------------------------------------------------------
KVector KCamera::GetPos()
{
        return KVector( m_Pos.x, m_Pos.y, m_Pos.z );
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::SetPos( float x, float y, float z )
{
        m_Pos.x = x;
        m_Pos.y = y;
        m_Pos.z = z;

        ComputeMatrix();
}

/*
//--------------------------------------------------------------------------------------------------------------------------------
KVector KCamera::GetDir()
{
        KMatrix         Matrix = GetMatrix();

        return KVector( Matrix._21, Matrix._23, Matrix._22 );
}
*/
//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::GetAxes( KVector& vRight, KVector& vUp, KVector& vView )
{
        KMatrix         Matrix = GetMatrix();

        vRight  = KVector( Matrix._11, Matrix._21, Matrix._31 );
        vUp             = KVector( Matrix._12, Matrix._22, Matrix._32 );
        vView   = KVector( Matrix._13, Matrix._23, Matrix._33 );
}

//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::GetFrustumPlanes( KPlane pPlanes[6] )
{
        KVector         vPos, vRight, vUp, vView;
        KVector         vzFar, vzNear;
        KVector         vx, vy;
        KVector         vUL, vUR, vDL, vDR;

        float           w, h;

        vPos = GetPos();
        GetAxes( vRight, vUp, vView );

        // Largeur & Hauteur du frustum au niveau du far plane
        w = m_Far * 2.0f * tanf( (m_Fov * ( PI / 180.0f )) / 2.0f );
        h = w / m_Aspect;

        vx              = vRight * ( w / 2.0f );
        vy              = vUp * ( h / 2.0f );
        vzFar   = vPos + ( vView * m_Far );
        vzNear  = vPos + ( vView * m_Near );
        vUL             = vzFar + vy - vx;
        vUR             = vzFar + vy + vx;
        vDL             = vzFar - vy - vx;
        vDR             = vzFar - vy + vx;

        // Near
        pPlanes[0] = KPlane( vzNear, vView );
        // Far
        pPlanes[1] = KPlane( vzFar, -vView );
        // Gauche
        pPlanes[2] = KPlane( vPos, vDL, vUL );
        // Droite
        pPlanes[3] = KPlane( vPos, vUR, vDR );
        // Haut
        pPlanes[4] = KPlane( vPos, vUL, vUR );
        // Bas
        pPlanes[5] = KPlane( vPos, vDR, vDL );
}


//--------------------------------------------------------------------------------------------------------------------------------
void KCamera::GetFrustumPoints( KVector pPoints[8] )
{
        KVector         vPos, vRight, vUp, vView;
        KVector         vzFar, vzNear;
        KVector         fvx, fvy, nvx, nvy;
        KVector         vUL, vUR, vDL, vDR;

        float           fw, fh, nw, nh;

        vPos = GetPos();
        GetAxes( vRight, vUp, vView );

        // Largeur & Hauteur du frustum au niveau du far plane
        fw = m_Far * 2.0f * tanf( (m_Fov * ( PI / 180.0f )) / 2.0f );
        fh = fw / m_Aspect;

        // Largeur & Hauteur du frustum au niveau du near plane
        nw = m_Near * 2.0f * tanf( (m_Fov * ( PI / 180.0f )) / 2.0f );
        nh = nw / m_Aspect;

        fvx             = vRight * ( fw / 2.0f );
        fvy             = vUp * ( fh / 2.0f );
        nvx             = vRight * ( nw / 2.0f );
        nvy             = vUp * ( nh / 2.0f );
        vzFar   = vPos + ( vView * m_Far );
        vzNear  = vPos + ( vView * m_Near );
        pPoints[0]      = vzFar + fvy - fvx;
        pPoints[1]      = vzFar + fvy + fvx;
        pPoints[2]      = vzFar - fvy - fvx;
        pPoints[3]      = vzFar - fvy + fvx;
        pPoints[4]      = vzNear + nvy - nvx;
        pPoints[5]      = vzNear + nvy + nvx;
        pPoints[6]      = vzNear - nvy - nvx;
        pPoints[7]      = vzNear - nvy + nvx;
}

//--------------------------------------------------------------------------------------------------------------------------------
KFrameCamera::KFrameCamera()
{
        m_nFrame        = 0;
        m_nKey          = 0;
        m_nFPS          = 10;
        m_pKeyFrameCamera = NULL;
        m_pKeyFrameTarget = NULL;
}

//--------------------------------------------------------------------------------------------------------------------------------
KFrameCamera::~KFrameCamera()
{
        if( m_pKeyFrameCamera )
                Deletep( m_pKeyFrameCamera );
        if( m_pKeyFrameTarget )
                Deletep( m_pKeyFrameTarget );
}

//--------------------------------------------------------------------------------------------------------------------------------
KVector KFrameCamera::GetKeyFramePos( KKeyFrameCamera* pKeyFrame, int Time )
{
        KASSERT( m_nKey );

        if( m_nKey == 1 )
                return pKeyFrame[ 0 ].m_Pos;

        float           Frame = (((float)Time / 1000.0f) * (float)m_nFPS);

        Frame = (float)fmod(Frame, (float)m_nFrame);

        KVector         PosPrevKey;
        KVector         PosNextKey;
        int                     FramePrevKey;
        int                     FrameNextKey;
        int                     Key;

        for(Key = 0; Key < m_nKey; Key ++)
        {
                if( ( pKeyFrame[ Key ].m_Frame <= Frame ) &&
                        ( pKeyFrame[ Key + 1].m_Frame > Frame ) )
                {
                        PosPrevKey              = pKeyFrame[ Key ].m_Pos;
                        FramePrevKey    = pKeyFrame[ Key ].m_Frame;
                        PosNextKey              = pKeyFrame[ Key + 1 ].m_Pos;
                        FrameNextKey    = pKeyFrame[ Key + 1 ].m_Frame;
                        break;
                }
        }

        float   delta = (Frame - (float)FramePrevKey ) / ((float)FrameNextKey - (float)FramePrevKey);

        KVector result = ((PosNextKey - PosPrevKey) * delta) + PosPrevKey;

        return result;
}

//--------------------------------------------------------------------------------------------------------------------------------
KVector KFrameCamera::GetCameraPos( int Time )
{
        return GetKeyFramePos( m_pKeyFrameCamera, Time );
}

//--------------------------------------------------------------------------------------------------------------------------------
KVector KFrameCamera::GetTargetPos( int Time )
{
        return GetKeyFramePos( m_pKeyFrameTarget, Time );
}

---