Public API Reference

csgeom/quaternion.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 by Norman Kramer
                  2006 by Marten Svanfeldt 

    This library 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 library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_QUATERNION_H__
#define __CS_QUATERNION_H__

#include "csextern.h"
#include "csqsqrt.h"

#include "csgeom/vector3.h"

class csMatrix3;

class CS_CRYSTALSPACE_EXPORT csQuaternion
{
public:
  // Constructors

  csQuaternion ()
    : v (0.0f), w (1.0f)
  {}

  csQuaternion (float x, float y, float z, float w)
    : v (x, y, z), w (w)
  {}

  csQuaternion (const csVector3& v, float w)
    : v (v), w (w)
  {}

  csQuaternion (const csQuaternion& q)
    : v (q.v), w (q.w)
  {}
  
  inline void SetIdentity () 
  {
    v.Set (0.0f); w = 1.0f;
  }

  inline friend csQuaternion operator+ (const csQuaternion& q1, 
    const csQuaternion& q2)
  {
    return csQuaternion (q1.v+q2.v, q1.w+q2.w);
  }

  inline csQuaternion& operator+= (const csQuaternion& q)
  {
    v += q.v; w += q.w;
    return *this;
  }

  inline friend csQuaternion operator- (const csQuaternion& q1, 
    const csQuaternion& q2)
  {
    return csQuaternion (q1.v-q2.v, q1.w-q2.w);
  }

  inline csQuaternion& operator-= (const csQuaternion& q)
  {
    v -= q.v; w -= q.w;
    return *this;
  }
  
  inline friend csQuaternion operator- (const csQuaternion& q)
  {
    return csQuaternion (-q.v, -q.w);
  }

  inline friend csQuaternion operator* (const csQuaternion& q1,
    const csQuaternion& q2)
  {
    return csQuaternion (q1.v*q2.w + q1.w*q2.v + q1.v%q2.v, 
      q1.w*q2.w - q1.v*q2.v);
  }

  inline csQuaternion& operator*= (const csQuaternion& q)
  {
    csVector3 newV = v*q.w + w*q.v + v%q.v;
    w = w*q.w - v*q.v;
    v = newV;
    return *this;
  }

  inline friend csQuaternion operator* (const csQuaternion q, float f)
  {
    return csQuaternion (q.v*f, q.w*f);
  }

  inline friend csQuaternion operator* (float f, const csQuaternion q)
  {
    return csQuaternion (q.v*f, q.w*f);
  }

  inline friend csQuaternion operator/ (const csQuaternion q, float f)
  {
    float invF = 1.0f/f;
    return csQuaternion (q.v*invF, q.w*invF);
  }

  inline friend csQuaternion operator/ (float f, const csQuaternion q)
  {
    float invF = 1.0f/f;
    return csQuaternion (q.v*invF, q.w*invF);
  }

  inline csQuaternion GetConjugate () const
  {
    return csQuaternion (-v, w);
  }

  inline void Conjugate () 
  {
    v = -v;
  }

  inline float Dot (const csQuaternion& q) const
  {
    return v*q.v + w*q.w;
  }

  inline float SquaredNorm () const
  {
    return Dot (*this);
  }

  inline float Norm () const
  {
    return csQsqrt (SquaredNorm ());
  }

  inline csQuaternion Unit () const
  {
    return (*this) / Norm ();
  }

  inline csVector3 Rotate (const csVector3& src) const
  {
    csQuaternion p (src, 0);
    csQuaternion q = *this * p;
    q *= GetConjugate ();
    return q.v;
  }

  inline void SetAxisAngle (const csVector3& axis, float angle)
  {
    v = axis * sinf (angle / 2.0f);
    w = cosf (angle / 2.0f);
  }

  inline void GetAxisAngle (csVector3& axis, float& angle) const
  {
    angle = 2.0f * acosf (w);
    if (v.SquaredNorm () != 0)
      axis = v.Unit ();
    else
      axis.Set (1.0f, 0.0f, 0.0f);
  }

  void SetEulerAngles (const csVector3& angles);

  csVector3 GetEulerAngles () const; 

  void SetMatrix (const csMatrix3& matrix);

  csMatrix3 GetMatrix () const;

  csQuaternion NLerp (const csQuaternion& q2, float t) const;

  csQuaternion SLerp (const csQuaternion& q2, float t) const;

  csQuaternion Log () const;

  csQuaternion Exp () const;

  csQuaternion Squad (const csQuaternion & t1, const csQuaternion & t2,
    const csQuaternion & q, float t) const;

  // Data
  csVector3 v;
  float w;
};

#endif // __CS_QUATERNION_H__

---