Quaternion.h

Go to the documentation of this file.

/*
Copyright (C) 2009 Jon Macey

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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef QUATERNION_H_
#define QUATERNION_H_
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
// must include types.h first for Real and GLEW if required
#include "Types.h"
#include "Vec4.h"

namespace ngl
{

// need to pre-declare the matrix class
class Mat4;


class NGL_DLLEXPORT Quaternion
{

  public:

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion(const Real _s=0.0f,const Real _x=0.0f,const Real _y=0.0f,const Real _z=0.0f) noexcept:
          m_s(_s),
          m_x(_x),
          m_y(_y),
          m_z(_z) {;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion(const Mat4 &_m) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion(const Vec3 &_rot) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion(const Quaternion& _q ) noexcept:
          m_s(_q.m_s),
          m_x(_q.m_x),
          m_y(_q.m_y),
          m_z(_q.m_z) {;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( Real _s,Real _x,Real _y,Real _z) noexcept
  {
    m_s=_s;
    m_x=_x;
    m_y=_y;
    m_z=_z;
  }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real getS() const  noexcept{return m_s;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real getX() const  noexcept{return m_x;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real getY() const  noexcept{return m_y;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real getZ() const  noexcept{return m_z;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 getVector() const  noexcept{return Vec4(m_x,m_y,m_z,0);}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setVector( const Vec4 &_v) noexcept
  {
    m_x=_v.m_x;
    m_y=_v.m_y;
    m_z=_v.m_z;
  }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setS(Real &_s) noexcept {m_s=_s;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setX(Real &_x) noexcept {m_x=_x;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setY(Real &_y) noexcept {m_y=_y;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setZ(Real &_z) noexcept  {m_z=_z;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion operator *(const Quaternion& _q) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator *=(const Quaternion& _q ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion operator *(Real _s ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator *=( Real _s ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion operator +(const Quaternion& _q ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion operator -( const Quaternion& _q) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator +=(const Quaternion& _q )  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator -=( const Quaternion& _q )  noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void normalise() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real magnitude() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion  conjugate() const  noexcept{return Quaternion(m_s,-m_x,-m_y,-m_z);}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion inverse()const  noexcept{return Quaternion(m_s,-m_x,-m_y,-m_z);}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator -() noexcept{m_x=-m_x; m_y=-m_y; m_z=-m_z;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion operator-() const noexcept {return Quaternion(m_s,-m_x,-m_y,-m_z ); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator == (const Quaternion& _q) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Quaternion slerp(const Quaternion &_q1,const Quaternion &_q2,const Real &_t) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator* (const Vec4 &_vec) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotateX(Real _angle) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotateY(Real _angle) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotateZ(Real _angle) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void fromAxisAngle(const Vec3 &_axis,Real _angle) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void fromEulerAngles(const Real _x,const Real _y,const Real _z) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotatePoint(const Quaternion& _r,Vec3 & io_p) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void toAxisAngle(Vec3 &o_axis,Real &o_angle) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4 toMat4() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4 toMat4Transpose() const noexcept;

  protected :
  Real m_s;
  Real m_x;
  Real m_y;
  Real m_z;

}; // end of class


}

#include "Mat4.h"

#endif