D:/Zythum/DinoKod/Common/Quaternion.cpp

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

//---------------------------------------------------------------------------------------------
KQuaternion::KQuaternion()
{
        m_W = 1.0f;
        m_X = 0.0f;
        m_Y = 0.0f;
        m_Z = 0.0f;
}

//---------------------------------------------------------------------------------------------
KQuaternion::KQuaternion( float W, float X, float Y, float Z )
{
        m_W = W;
        m_X = X;
        m_Y = Y;
        m_Z = Z;
}

//---------------------------------------------------------------------------------------------
void KQuaternion::SetAxis( float Angle, KVector& Axe )
{
        float   Omega = Angle * 0.5f;
        float   Sin = sinf( Omega );

        m_W = cosf( Omega );
        m_X = Sin * Axe.x;
        m_Y = Sin * Axe.y;
        m_Z = Sin * Axe.z;
}

//---------------------------------------------------------------------------------------------
void KQuaternion::SetEuler( float Angle, float Pitch, float Roll, float Yaw )
{
        float   CosY = cosf( Yaw * 0.5f );
        float   SinY = sinf( Yaw * 0.5f );
        float   CosP = cosf( Pitch * 0.5f );
        float   SinP = sinf( Pitch * 0.5f );
        float   CosR = cosf( Roll * 0.5f );
        float   SinR = sinf( Roll * 0.5f );

        m_W = CosR * SinP * CosY + SinR * CosP * SinY;
        m_X = CosR * CosP * SinY - SinR * SinP * CosY;
        m_Y = SinR * CosP * CosY - CosR * SinP * SinY;
        m_Z = CosR * CosP * CosY + SinR * SinP * SinY;
}

//---------------------------------------------------------------------------------------------
void KQuaternion::GetAxis( float* pAngle, KVector* pAxe )
{
        *pAngle = 2.0f * acosf( m_W );

        float   Scale = sqrtf( m_X * m_X + m_Y * m_Y + m_Z * m_Z );

        pAxe->x = m_X / Scale;
        pAxe->y = m_Y / Scale;
        pAxe->z = m_Z / Scale;
}

//---------------------------------------------------------------------------------------------
void KQuaternion::GetEuler( float* pAngle, float* pPitch, float* pRoll, float* pYaw )
{
        
}

//---------------------------------------------------------------------------------------------
KMatrix KQuaternion::GetMatrix()
{
        KMatrix m;
        
        m._11 = 1.0f - 2.0f * SQR( m_Y ) - 2.0f * SQR( m_Z );
        m._12 = 2.0f * m_X * m_Y + 2.0f * m_W * m_Z;
        m._13 = 2.0f * m_X * m_Z - 2.0f * m_W * m_Y;
        m._14 = 0.0f;

        m._21 = 2.0f * m_X * m_Y - 2.0f * m_W * m_Z;
        m._22 = 1.0f - 2.0f * SQR( m_X ) - 2.0f * SQR( m_Z );
        m._23 = 2.0f * m_Y * m_Z + 2.0f * m_W * m_X;
        m._24 = 0.0f;

        m._31 = 2.0f * m_X * m_Z + 2.0f * m_W * m_Y;
        m._32 = 2.0f * m_Y * m_Z - 2.0f * m_W * m_X;
        m._33 = 1.0f - 2.0f * SQR( m_X ) - 2.0f * SQR( m_Y );
        m._34 = 0.0f;

        m._41 = 0.0f;
        m._42 = 0.0f;
        m._43 = 0.0f;
        m._44 = 1.0f;

        return m;
}
/*
Matrix =  [ 1 - 2y² - 2z²    2xy - 2wz      2xz + 2wy
              2xy + 2wz    1 - 2x² - 2z²    2yz - 2wx
              2xz - 2wy      2yz + 2wx    1 - 2x² - 2y² ]
*/

//---------------------------------------------------------------------------------------------
KQuaternion KQuaternion::operator *( KQuaternion& Q )
{
        return KQuaternion(     m_W * Q.m_W - m_X * Q.m_X - m_Y * Q.m_Y - m_Z * Q.m_Z,
                                                m_W * Q.m_X + m_X * Q.m_W + m_Y * Q.m_Z - m_Z * Q.m_Y,
                                                m_W * Q.m_Y + m_Y * Q.m_W + m_Z * Q.m_X - m_X * Q.m_Z,
                                                m_W * Q.m_Z + m_Z * Q.m_W + m_X * Q.m_Y - m_Y * Q.m_X );
}

---