GLQuaternion.h

/***************************************************************************
 *   Copyright (C) 2004 by Jacques Gasselin                                *
 *   jacquesgasselin@hotmail.com                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library 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 Library 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.             *
 ***************************************************************************/
#ifndef GLQUATERNION_H
#define GLQUATERNION_H

#include "GLVector.h"
#include "GLMatrix.h"

namespace mathglpp
{
template <class T>
class GLQuaternion
{
public:
    GLQuaternion()
    :w(1),v(0,0,0)
    {}

    GLQuaternion(T f, const GLVector3<T>& gv)
    :w(f),v(gv)
    {}

    GLQuaternion(const GLVector3<T>& gv)
    :w(0),v(gv)
    {}

    GLQuaternion(const T* gq)
    :w(gq[0]),v(gq+1)
    {}

    GLQuaternion(const GLQuaternion& gq)
    :w(gq.w),v(gq.v)
    {}


    GLQuaternion(GLVector3<T> gv, T degrees)
    {   set(gv.unit(), degrees); }

    ~GLQuaternion(){}

    inline T getW()
    {   return w; }

    inline const GLVector3<T>& getV()
    {   return v; }

    inline void set(T _w, const GLVector3<T>& gv)
    {   w = _w; v = gv; }

    inline void set(T _w, T x, T y, T z)
    {   w = _w; v.set(x,y,z); }

    inline void set(const T* gq)
    {   set(gq[0],gq[1],gq[2],gq[3]); }

    inline void set(GLVector3<T> vec, T degrees)
    {   set(cos(degrees*M_PI/360.0), vec * sin(degrees*M_PI/360.0) ); }

    GLQuaternion operator + (GLQuaternion gq)
    {   GLQuaternion temp(*this); temp += gq; return temp; }

    GLQuaternion operator - (GLQuaternion gq)
    {   GLQuaternion temp(*this); temp -= gq; return temp; }

    GLQuaternion& operator += (GLQuaternion gq)
    {   w += gq.w; v += gq.v; return *this; }

    GLQuaternion& operator -= (GLQuaternion gq)
    {   w -= gq.w; v -= gq.v; return *this; }

    GLQuaternion operator * (GLQuaternion gq)
    {   GLQuaternion temp(*this); temp *=  gq; return temp; }

    GLQuaternion operator / (T f)
    {   GLQuaternion temp(*this); temp /= f; return temp; }

    GLQuaternion& operator *= (GLQuaternion gq)
    {   set( w * gq.w - v.dot(gq.v) , (gq.v * w) + (v * gq.w) + v.getCross(gq.v) ); return *this; }

    GLQuaternion& operator /= (T f)
    {   set( w / f , v / f ); return *this; }

    T dot(GLQuaternion gq)
    {   return ( w*gq.w + v.dot(gq.v) ); }

    GLQuaternion getCross(GLQuaternion gq)
    {   return GLQuaternion( w * gq.w - v.dot(gq.v) , (gq.v * w) + (v * gq.w) + v.getCross(gq.v) ); }

    GLQuaternion getConjugate()
    {   GLQuaternion temp(*this); temp.conjugate(); return temp; }

    GLQuaternion& conjugate()
    {   v = -v; return *this; }

    GLQuaternion getInverse()
    {   GLQuaternion temp(*this); temp.inverse(); return temp; }

    GLQuaternion& inverse()
    {   conjugate(); *this /= norm(); return *this; }

    T selection()
    {   return w; }

    T norm()
    {   return sqrt( w*w + v.lengthSqr() ); }

    GLQuaternion unit() const
    {   return this->operator /(norm()); }

    inline GLQuaternion& normalise(){ return normalize(); }
   
    GLQuaternion& normalize()
    {   return this->operator /=(norm()); }

    GLVector3<T> rotateVector(const GLVector3<T>& gv)
    {   GLQuaternion temp = getCross(GLQuaternion(gv)); temp *= getConjugate(); return temp.v; }

    GLMatrix<T> matrix(void)
    {
        GLMatrix<T> temp;

        T xx=v.x*v.x;  T xy=v.x*v.y;  T xz=v.x*v.z;  T xw=v.x*w;
        T yy=v.y*v.y;  T yz=v.y*v.z;  T yw=v.y*w;
        T zz=v.z*v.z;  T zw=v.z*w;

        temp[0] = 1 - 2*(zz + yy);
        temp[1] = 2*(xy + zw);
        temp[2] = 2*(xz - yw);
        temp[3] = 0;

        temp[4] = 2*(xy - zw);
        temp[5] = 1 - 2*(zz + xx);
        temp[6] = 2*(yz + xw);
        temp[7] = 0;

        temp[8] = 2*(yw + xz);
        temp[9] = 2*(yz - xw);
        temp[10] = 1 - 2*(yy + xx);
        temp[11] = 0;

        temp[12] = 0;
        temp[13] = 0;
        temp[14] = 0;
        temp[15] = 1;

        return temp;
    }

private:
    T w;
    GLVector3<T> v;
};

typedef GLQuaternion<GLfloat> GLQuaternionf;
typedef GLQuaternion<GLdouble> GLQuaterniond;

};

#endif

---