K3dQuaternion.h

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.             *
 ***************************************************************************/


#pragma once

#include "K3dVector4.h"
#include "K3dMatrix.h"


class K3dQuaternion
{
        public:
                // A quaternion is q = w + x*i + y*j + z*k where (w,x,y,z) is not
                // necessarily a unit length vector in 4D.

                K3dQuaternion ();
                K3dQuaternion ( float fW, float fX, float fY, float fZ );
                K3dQuaternion ( K3dQuaternion& rkQ );
                K3dQuaternion ( K3dVector4 kVec4 );
                K3dQuaternion ( float afVector[4] );
                ~K3dQuaternion();
                K3dQuaternion ( K3dMatrix& rkRot );

                K3dQuaternion ( K3dVector3& rkAxis, float fAngle );

                K3dQuaternion ( K3dVector3 akRotColumn[3] );

                operator const float* () const;
                operator float* ();
                float operator[] ( int i ) const;
                float& operator[] ( int i );
                float W () const;
                float& W ();
                float X () const;
                float& X ();
                float Y () const;
                float& Y ();
                float Z () const;
                float& Z ();

                K3dQuaternion& operator= ( K3dQuaternion& rkQ );
                bool operator== ( K3dQuaternion& rkQ ) ;
                bool operator!= ( K3dQuaternion& rkQ ) ;
                bool operator< ( K3dQuaternion& rkQ ) ;
                bool operator<= ( K3dQuaternion& rkQ ) ;
                bool operator> ( K3dQuaternion& rkQ ) ;
                bool operator>= ( K3dQuaternion& rkQ ) ;

                K3dQuaternion& operator+ ( K3dQuaternion& rkQ ) ;
                K3dQuaternion& operator- ( K3dQuaternion& rkQ ) ;
                K3dQuaternion& operator* ( K3dQuaternion& rkQ ) ;
                K3dQuaternion& operator* ( float fScalar ) ;
                K3dQuaternion& operator/ ( float fScalar ) ;
                K3dQuaternion& operator- () ;

                K3dQuaternion& operator+= ( K3dQuaternion& rkQ );
                K3dQuaternion& operator-= ( K3dQuaternion& rkQ );
                K3dQuaternion& operator*= ( float fScalar );
                K3dQuaternion& operator/= ( float fScalar );

                // conversion between quaternions, matrices, and axis-angle
                void FromRotationMatrix ( K3dMatrix& rkRot );
                void ToRotationMatrix ( K3dMatrix& rkRot ) ;
                //void ToRotationGlMatrix (K3dMatrix& rkRot) const;
                void FromRotationMatrix ( K3dVector3 akRotColumn[3] );
                void ToRotationMatrix ( K3dVector3 akRotColumn[3] ) ;
                void FromAxisAngle ( K3dVector3& rkAxis, float fAngle );
                void FromAxisAngle ( K3dVector3 _kAngle );
                void ToAxisAngle ( K3dVector3& rkAxis, float& rfAngle ) ;

                float Dot ( K3dQuaternion& rkQ ) ;
                K3dQuaternion& Inverse () ;
                K3dQuaternion& Conjugate () ;
                K3dQuaternion& Exp ();
                K3dQuaternion& Log ();

                // rotation of a vector by a quaternion
                K3dVector3& operator* ( K3dVector3& rkVector );
//      K3dQuaternion operator* (float fScalar, const K3dQuaternion& rkQ);

                K3dQuaternion& Slerp ( float fT, K3dQuaternion& rkP, K3dQuaternion& rkQ );
                K3dQuaternion& SlerpExtraSpins ( float fT, K3dQuaternion& rkP, K3dQuaternion& rkQ, int iExtraSpins );

                K3dQuaternion& GetIntermediate ( K3dQuaternion& rkQ0, K3dQuaternion& rkQ1,  K3dQuaternion& rkQ2 );

                K3dQuaternion& Squad ( float fT,  K3dQuaternion& rkQ0, K3dQuaternion& rkA0,  K3dQuaternion& rkA1, K3dQuaternion& rkQ1 );

                void GetValue ( K3dMatrix & rkMatrix ) ;

                static const float IDENTITY[4];  // the identity rotation
                static const float ZERO[4];




        protected:
                int CompareArrays ( K3dQuaternion& rkQ ) ;
                static const int NEXT[3];

                float m_afTuple[4];
};

---