K3dQuaternion.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 "K3dQuaternion.h"

#define     EQUIVALENT(a,b)     (((a < b + K3dMath::EPSILON) && (a > b - K3dMath::EPSILON)) ? true : false)





K3dQuaternion::K3dQuaternion ( void )
{
}

K3dQuaternion::~K3dQuaternion ( void )
{
}

K3dQuaternion::K3dQuaternion ( float fX, float fY, float fZ, float fW )
{
        m_afTuple[0] = fX;
        m_afTuple[1] = fY;
        m_afTuple[2] = fZ;
        m_afTuple[3] = fW;
}

K3dQuaternion::K3dQuaternion ( K3dVector4 kVec4 )
{
        m_afTuple[0] = kVec4[0];
        m_afTuple[1] = kVec4[1];
        m_afTuple[2] = kVec4[2];
        m_afTuple[3] = kVec4[3];
}

K3dQuaternion::K3dQuaternion ( float afVector[4] )
{
        for ( int i=0; i<4; i++ )
        {
                m_afTuple[i] = afVector[i];
        }
}

K3dQuaternion::K3dQuaternion ( K3dQuaternion& rkQ )
{
        memcpy ( m_afTuple,rkQ.m_afTuple,4*sizeof ( float ) );
}

K3dQuaternion::K3dQuaternion ( K3dMatrix& rkRot )
{
        FromRotationMatrix ( rkRot );
}

K3dQuaternion::K3dQuaternion ( K3dVector3& rkAxis, float fAngle )
{
        FromAxisAngle ( rkAxis,fAngle );
}

K3dQuaternion::K3dQuaternion ( K3dVector3 akRotColumn[3] )
{
        FromRotationMatrix ( akRotColumn );
}

K3dQuaternion::operator const float* () const
{
        return m_afTuple;
}

K3dQuaternion::operator float* ()
{
        return m_afTuple;
}

float& K3dQuaternion::operator[] ( int i )
{
        if ( ! ( 0 <= i && i < 4 ) )
        {
                cerr << "float K3dQuaternion::operator[] (int i) const -- Error index" << endl;
        }
        return m_afTuple[i];
}

float K3dQuaternion::W () const
{
        return m_afTuple[3];
}

float& K3dQuaternion::W ()
{
        return m_afTuple[3];
}

float K3dQuaternion::X () const
{
        return m_afTuple[0];
}

float& K3dQuaternion::X ()
{
        return m_afTuple[0];
}

float K3dQuaternion::Y () const
{
        return m_afTuple[1];
}

float& K3dQuaternion::Y ()
{
        return m_afTuple[1];
}

float K3dQuaternion::Z () const
{
        return m_afTuple[2];
}

float& K3dQuaternion::Z ()
{
        return m_afTuple[2];
}

K3dQuaternion& K3dQuaternion::operator= ( K3dQuaternion& rkQ )
{
        memcpy ( m_afTuple,rkQ.m_afTuple,4*sizeof ( float ) );
        return *this;
}

bool K3dQuaternion::operator== ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
        {
                if ( m_afTuple[i] != rkQ.m_afTuple[i] )
                        return false;
        }
        return true;
}

bool K3dQuaternion::operator!= ( K3dQuaternion& rkQ )
{
        return !operator== ( rkQ );
}

int K3dQuaternion::CompareArrays ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
        {
                unsigned int uiTest0 = * ( unsigned int* ) &m_afTuple[i];
                unsigned int uiTest1 = * ( unsigned int* ) &rkQ.m_afTuple[i];
                if ( uiTest0 < uiTest1 )
                        return -1;
                if ( uiTest0 > uiTest1 )
                        return +1;
        }
        return 0;
}

bool K3dQuaternion::operator< ( K3dQuaternion& rkQ )
{
        return CompareArrays ( rkQ ) < 0;
}

bool K3dQuaternion::operator<= ( K3dQuaternion& rkQ )
{
        return CompareArrays ( rkQ ) <= 0;
}

bool K3dQuaternion::operator> ( K3dQuaternion& rkQ )
{
        return CompareArrays ( rkQ ) > 0;
}

bool K3dQuaternion::operator>= ( K3dQuaternion& rkQ )
{
        return CompareArrays ( rkQ ) >= 0;
}

K3dQuaternion& K3dQuaternion::operator+ ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] = m_afTuple[i] + rkQ.m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator- ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] = m_afTuple[i] - rkQ.m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator* ( K3dQuaternion& rkQ )
{
        K3dQuaternion kProd;

        kProd.m_afTuple[0] =
            m_afTuple[0]*rkQ.m_afTuple[0] -
            m_afTuple[1]*rkQ.m_afTuple[1] -
            m_afTuple[2]*rkQ.m_afTuple[2] -
            m_afTuple[3]*rkQ.m_afTuple[3];

        kProd.m_afTuple[1] =
            m_afTuple[0]*rkQ.m_afTuple[1] +
            m_afTuple[1]*rkQ.m_afTuple[0] +
            m_afTuple[2]*rkQ.m_afTuple[3] -
            m_afTuple[3]*rkQ.m_afTuple[2];

        kProd.m_afTuple[2] =
            m_afTuple[0]*rkQ.m_afTuple[2] +
            m_afTuple[2]*rkQ.m_afTuple[0] +
            m_afTuple[3]*rkQ.m_afTuple[1] -
            m_afTuple[1]*rkQ.m_afTuple[3];

        kProd.m_afTuple[3] =
            m_afTuple[0]*rkQ.m_afTuple[3] +
            m_afTuple[3]*rkQ.m_afTuple[0] +
            m_afTuple[1]*rkQ.m_afTuple[2] -
            m_afTuple[2]*rkQ.m_afTuple[1];

        *this = kProd;

        return *this;
}

K3dQuaternion& K3dQuaternion::operator* ( float fScalar )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] = fScalar*m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator/ ( float fScalar )
{
        int i;

        if ( fScalar != ( float ) 0.0 )
        {
                float fInvScalar = ( ( float ) 1.0 ) /fScalar;
                for ( i = 0; i < 4; i++ )
                        m_afTuple[i] = fInvScalar*m_afTuple[i];
        }
        else
        {
                for ( i = 0; i < 4; i++ )
                        m_afTuple[i] = K3dMath::MAX_REAL;
        }

        return *this;
}

K3dQuaternion& K3dQuaternion::operator- ()
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] = -m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator+= ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] += rkQ.m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator-= ( K3dQuaternion& rkQ )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] -= rkQ.m_afTuple[i];
        return *this;
}

K3dQuaternion& K3dQuaternion::operator*= ( float fScalar )
{
        for ( int i = 0; i < 4; i++ )
                m_afTuple[i] *= fScalar;
        return *this;
}

K3dQuaternion& K3dQuaternion::operator/= ( float fScalar )
{
        int i;

        if ( fScalar != ( float ) 0.0 )
        {
                float fInvScalar = ( ( float ) 1.0 ) /fScalar;
                for ( i = 0; i < 4; i++ )
                        m_afTuple[i] *= fInvScalar;
        }
        else
        {
                for ( i = 0; i < 4; i++ )
                        m_afTuple[i] = K3dMath::MAX_REAL;
        }

        return *this;
}

void K3dQuaternion::FromRotationMatrix ( K3dMatrix& rkRot )
{
        // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
        // article "Quaternion Calculus and Fast Animation".

        float fTrace = rkRot ( 0,0 ) + rkRot ( 1,1 ) + rkRot ( 2,2 );
        float fRoot;

        if ( fTrace > ( float ) 0.0 )
        {
                // |w| > 1/2, may as well choose w > 1/2
                fRoot = K3dMath::Sqrt ( fTrace + ( float ) 1.0 );  // 2w
                m_afTuple[0] = ( ( float ) 0.5 ) *fRoot;
                fRoot = ( ( float ) 0.5 ) /fRoot;  // 1/(4w)
                m_afTuple[1] = ( rkRot ( 2,1 )-rkRot ( 1,2 ) ) *fRoot;
                m_afTuple[2] = ( rkRot ( 0,2 )-rkRot ( 2,0 ) ) *fRoot;
                m_afTuple[3] = ( rkRot ( 1,0 )-rkRot ( 0,1 ) ) *fRoot;
        }
        else
        {
                // |w| <= 1/2
                int i = 0;
                if ( rkRot ( 1,1 ) > rkRot ( 0,0 ) )
                        i = 1;
                if ( rkRot ( 2,2 ) > rkRot ( i,i ) )
                        i = 2;
                int j = NEXT[i];
                int k = NEXT[j];

                fRoot = K3dMath::Sqrt ( rkRot ( i,i )-rkRot ( j,j )-rkRot ( k,k ) + ( float ) 1.0 );
                float* apfQuat[3] = { &m_afTuple[1], &m_afTuple[2], &m_afTuple[3] };
                *apfQuat[i] = ( ( float ) 0.5 ) *fRoot;
                fRoot = ( ( float ) 0.5 ) /fRoot;
                m_afTuple[0] = ( rkRot ( k,j )-rkRot ( j,k ) ) *fRoot;
                *apfQuat[j] = ( rkRot ( j,i ) +rkRot ( i,j ) ) *fRoot;
                *apfQuat[k] = ( rkRot ( k,i ) +rkRot ( i,k ) ) *fRoot;
        }
}

void K3dQuaternion::ToRotationMatrix ( K3dMatrix& _rkRot )
{
        _rkRot[0] = ( 1.0f - 2.0f * m_afTuple[1] * m_afTuple[1] - 2.0f * m_afTuple[2] * m_afTuple[2] );
        _rkRot[1] = ( 2.0f * m_afTuple[0] * m_afTuple[1] + 2.0f * m_afTuple[3] * m_afTuple[2] );
        _rkRot[2] = ( 2.0f * m_afTuple[0] * m_afTuple[2] - 2.0f * m_afTuple[3] * m_afTuple[1] );

        _rkRot[4] = ( 2.0f * m_afTuple[0] * m_afTuple[1] - 2.0f * m_afTuple[3] * m_afTuple[2] );
        _rkRot[5] = ( 1.0f - 2.0f * m_afTuple[0] * m_afTuple[0] - 2.0f * m_afTuple[2] * m_afTuple[2] );
        _rkRot[6] = ( 2.0f * m_afTuple[1] * m_afTuple[2] + 2.0f * m_afTuple[3] * m_afTuple[0] );

        _rkRot[8] = ( 2.0f * m_afTuple[0] * m_afTuple[2] + 2.0f * m_afTuple[3] * m_afTuple[1] );
        _rkRot[9] = ( 2.0f * m_afTuple[1] * m_afTuple[2] - 2.0f * m_afTuple[3] * m_afTuple[0] );
        _rkRot[10] = ( 1.0f - 2.0f * m_afTuple[0] * m_afTuple[0] - 2.0f * m_afTuple[1] * m_afTuple[1] );
}

void K3dQuaternion::FromRotationMatrix ( K3dVector3 akRotColumn[3] )
{
        K3dMatrix kRot;
        for ( int iCol = 0; iCol < 3; iCol++ )
        {
                kRot ( 0,iCol ) = akRotColumn[iCol][0];
                kRot ( 1,iCol ) = akRotColumn[iCol][1];
                kRot ( 2,iCol ) = akRotColumn[iCol][2];
        }
        FromRotationMatrix ( kRot );
}


void K3dQuaternion::ToRotationMatrix ( K3dVector3 akRotColumn[3] )
{
        K3dMatrix kRot;
        ToRotationMatrix ( kRot );
        for ( int iCol = 0; iCol < 3; iCol++ )
        {
                akRotColumn[iCol][0] = kRot ( 0,iCol );
                akRotColumn[iCol][1] = kRot ( 1,iCol );
                akRotColumn[iCol][2] = kRot ( 2,iCol );
        }
}



void K3dQuaternion::FromAxisAngle ( K3dVector3 _kAngle )
{
        float fAngle;
        K3dVector3 kSin, kCos;

        fAngle = _kAngle[0] * 0.5f;
        kSin[0] = sin ( fAngle );
        kCos[0] = cos ( fAngle );
        fAngle = _kAngle[1] * 0.5f;
        kSin[1] = sin ( fAngle );
        kCos[1] = cos ( fAngle );
        fAngle = _kAngle[2] * 0.5f;
        kSin[2] = sin ( fAngle );
        kCos[2] = cos ( fAngle );

        float fSqrCos = kCos[0] * kCos[1];
        float fSqrSin = kSin[0] * kSin[1];

        m_afTuple[0] = ( float ) ( kSin[0] * kCos[1] * kCos[2] - kCos[0] * kSin[1] * kSin[2] );
        m_afTuple[1] = ( float ) ( kCos[0] * kSin[1] * kCos[2] + kSin[0] * kCos[1] * kSin[2] );
        m_afTuple[2] = ( float ) ( fSqrCos * kSin[2] - fSqrSin * kCos[2] );
        m_afTuple[3] = ( float ) ( fSqrCos * kCos[2] + fSqrSin * kSin[2] );
}

void K3dQuaternion::FromAxisAngle ( K3dVector3& rkAxis, float fAngle )
{
        float fHalfAngle = ( ( float ) 0.5 ) *fAngle;
        float fSin = K3dMath::Sin ( fHalfAngle );
        m_afTuple[0] = K3dMath::Cos ( fHalfAngle );
        m_afTuple[1] = fSin*rkAxis[0];
        m_afTuple[2] = fSin*rkAxis[1];
        m_afTuple[3] = fSin*rkAxis[2];
}

void K3dQuaternion::ToAxisAngle ( K3dVector3& rkAxis, float& rfAngle )
{
        float fSqrLength = m_afTuple[1]*m_afTuple[1] + m_afTuple[2]*m_afTuple[2]
                           + m_afTuple[3]*m_afTuple[3];
        if ( fSqrLength > K3dMath::EPSILON )
        {
                rfAngle = ( ( float ) 2.0 ) *K3dMath::ACos ( m_afTuple[0] );
                float fInvLength = K3dMath::InvSqrt ( fSqrLength );
                rkAxis[0] = m_afTuple[1]*fInvLength;
                rkAxis[1] = m_afTuple[2]*fInvLength;
                rkAxis[2] = m_afTuple[3]*fInvLength;
        }
        else
        {
                // angle is 0 (mod 2*pi), so any axis will do
                rfAngle = ( float ) 0.0;
                rkAxis[0] = ( float ) 1.0;
                rkAxis[1] = ( float ) 0.0;
                rkAxis[2] = ( float ) 0.0;
        }
}

float K3dQuaternion::Dot ( K3dQuaternion& rkQ )
{
        float fDot = ( float ) 0.0;
        for ( int i = 0; i < 4; i++ )
                fDot += m_afTuple[i]*rkQ.m_afTuple[i];
        return fDot;
}

K3dQuaternion& K3dQuaternion::Inverse ()
{
        K3dQuaternion kInverse;

        float fNorm = ( float ) 0.0;
        int i;
        for ( i = 0; i < 4; i++ )
                fNorm += m_afTuple[i]*m_afTuple[i];

        if ( fNorm > ( float ) 0.0 )
        {
                float fInvNorm = ( ( float ) 1.0 ) /fNorm;
                kInverse.m_afTuple[0] = m_afTuple[0]*fInvNorm;
                kInverse.m_afTuple[1] = -m_afTuple[1]*fInvNorm;
                kInverse.m_afTuple[2] = -m_afTuple[2]*fInvNorm;
                kInverse.m_afTuple[3] = -m_afTuple[3]*fInvNorm;
        }
        else
        {
                // return an invalid result to flag the error
                for ( i = 0; i < 4; i++ )
                        kInverse.m_afTuple[i] = ( float ) 0.0;
        }
        *this = kInverse;
        return *this;

}

K3dQuaternion& K3dQuaternion::Conjugate ()
{
        m_afTuple[0] = - m_afTuple[0];
        m_afTuple[1] = - m_afTuple[1];
        m_afTuple[2] = - m_afTuple[2];

        return *this;
}

K3dQuaternion& K3dQuaternion::Exp ()
{
        K3dQuaternion kResult;

        float fAngle = K3dMath::Sqrt ( m_afTuple[1]*m_afTuple[1] +
                                       m_afTuple[2]*m_afTuple[2] + m_afTuple[3]*m_afTuple[3] );

        float fSin = K3dMath::Sin ( fAngle );
        kResult.m_afTuple[0] = K3dMath::Cos ( fAngle );

        int i;

        if ( K3dMath::FAbs ( fSin ) >= K3dMath::EPSILON )
        {
                float fCoeff = fSin/fAngle;
                for ( i = 1; i <= 3; i++ )
                        kResult.m_afTuple[i] = fCoeff*m_afTuple[i];
        }
        else
        {
                for ( i = 1; i <= 3; i++ )
                        kResult.m_afTuple[i] = m_afTuple[i];
        }
        *this = kResult;
        return *this;
}

K3dQuaternion& K3dQuaternion::Log ()
{
        K3dQuaternion kResult;
        kResult.m_afTuple[0] = ( float ) 0.0;

        int i;

        if ( K3dMath::FAbs ( m_afTuple[0] ) < ( float ) 1.0 )
        {
                float fAngle = K3dMath::ACos ( m_afTuple[0] );
                float fSin = K3dMath::Sin ( fAngle );
                if ( K3dMath::FAbs ( fSin ) >= K3dMath::EPSILON )
                {
                        float fCoeff = fAngle/fSin;
                        for ( i = 1; i <= 3; i++ )
                                kResult.m_afTuple[i] = fCoeff*m_afTuple[i];
                        *this = kResult;
                        return *this;
                }
        }

        for ( i = 1; i <= 3; i++ )
                kResult.m_afTuple[i] = m_afTuple[i];
        *this = kResult;
        return *this;
}

K3dVector3& K3dQuaternion::operator* ( K3dVector3& rkVector )
{
        K3dMatrix kRot;
        ToRotationMatrix ( kRot );
        rkVector = kRot*rkVector;
        return rkVector;
}


K3dQuaternion& K3dQuaternion::Slerp ( float fT, K3dQuaternion& rkP, K3dQuaternion& rkQ )
{
        float fCos = rkP.Dot ( rkQ );
        float fAngle = K3dMath::ACos ( fCos );

        if ( K3dMath::FAbs ( fAngle ) < K3dMath::EPSILON )
                return rkP;

        float fSin = K3dMath::Sin ( fAngle );
        float fInvSin = ( ( float ) 1.0 ) /fSin;
        float fCoeff0 = K3dMath::Sin ( ( ( ( float ) 1.0 )-fT ) *fAngle ) *fInvSin;
        float fCoeff1 = K3dMath::Sin ( fT*fAngle ) *fInvSin;
        rkP = rkP*fCoeff0;
        rkQ = rkQ*fCoeff1;

        return rkP + rkQ;
}


K3dQuaternion& K3dQuaternion::SlerpExtraSpins ( float fT,
        K3dQuaternion& rkP, K3dQuaternion& rkQ, int iExtraSpins )
{
        float fCos = rkP.Dot ( rkQ );
        float fAngle = K3dMath::ACos ( fCos );

        if ( K3dMath::FAbs ( fAngle ) < K3dMath::EPSILON )
                return rkP;

        float fSin = K3dMath::Sin ( fAngle );
        float fPhase = K3dMath::K_PI*iExtraSpins*fT;
        float fInvSin = ( ( float ) 1.0 ) /fSin;
        float fCoeff0 = K3dMath::Sin ( ( ( ( float ) 1.0 )-fT ) *fAngle-fPhase ) *fInvSin;
        float fCoeff1 = K3dMath::Sin ( fT*fAngle + fPhase ) *fInvSin;
        return rkP*fCoeff0 + rkQ*fCoeff1;
}


K3dQuaternion& K3dQuaternion::GetIntermediate ( K3dQuaternion& rkQ0,
        K3dQuaternion& rkQ1, K3dQuaternion& rkQ2 )
{
        K3dQuaternion kQ1Inv = rkQ1.Conjugate();
        K3dQuaternion kP0 = kQ1Inv*rkQ0;
        K3dQuaternion kP2 = kQ1Inv*rkQ2;
        K3dQuaternion kArg = - ( ( kP0.Log() * ( float ) 0.25 ) +kP2.Log() );
        K3dQuaternion kA = rkQ1*kArg.Exp();
        *this = kA;
        return *this;
}


K3dQuaternion& K3dQuaternion::Squad ( float fT,  K3dQuaternion& rkQ0,
                                      K3dQuaternion& rkA0,  K3dQuaternion& rkA1,  K3dQuaternion& rkQ1 )
{
        float fSlerpT = ( ( float ) 2.0 ) *fT* ( ( ( float ) 1.0 )-fT );
        K3dQuaternion kSlerpP = Slerp ( fT,rkQ0,rkQ1 );
        K3dQuaternion kSlerpQ = Slerp ( fT,rkA0,rkA1 );
        return Slerp ( fSlerpT,kSlerpP,kSlerpQ );
}


void K3dQuaternion::GetValue ( K3dMatrix & rkMatrix )
{
        float s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;

        float fNorm = m_afTuple[0] * m_afTuple[0] + m_afTuple[1] * m_afTuple[1] + m_afTuple[2] * m_afTuple[2] + m_afTuple[3] * m_afTuple[3];

        s = ( EQUIVALENT ( fNorm, ( float ) 0 ) ) ? ( float ) 0 : ( ( float ) 2 / fNorm );

        xs = m_afTuple[0] * s;
        ys = m_afTuple[1] * s;
        zs = m_afTuple[2] * s;

        wx = m_afTuple[3] * xs;
        wy = m_afTuple[3] * ys;
        wz = m_afTuple[3] * zs;

        xx = m_afTuple[0] * xs;
        xy = m_afTuple[0] * ys;
        xz = m_afTuple[0] * zs;

        yy = m_afTuple[1] * ys;
        yz = m_afTuple[1] * zs;
        zz = m_afTuple[2] * zs;

        rkMatrix ( 0,0 ) = float ( ( float ) 1 - ( yy + zz ) );
        rkMatrix ( 1,0 ) = float ( xy + wz );
        rkMatrix ( 2,0 ) = float ( xz - wy );

        rkMatrix ( 0,1 ) = float ( xy - wz );
        rkMatrix ( 1,1 ) = float ( ( float ) 1 - ( xx + zz ) );
        rkMatrix ( 2,1 ) = float ( yz + wx );

        rkMatrix ( 0,2 ) = float ( xz + wy );
        rkMatrix ( 1,2 ) = float ( yz - wx );
        rkMatrix ( 2,2 ) = float ( ( float ) 1 - ( xx + yy ) );

        rkMatrix ( 3,0 ) = rkMatrix ( 3,1 ) = rkMatrix ( 3,2 ) = rkMatrix ( 0,3 ) = rkMatrix ( 1,3 ) = rkMatrix ( 2,3 ) = ( float ) 0;
        rkMatrix ( 3,3 ) = ( float ) 1;
}


const float K3dQuaternion::IDENTITY[4] = {1.0f,0.0f,0.0f,0.0f};
const float K3dQuaternion::ZERO[4] = {0.0f,0.0f,0.0f,0.0f};
const int K3dQuaternion::NEXT[3] = { 1, 2, 0 };

---