Subversion Repositories gelsvn

#ifndef __CGLA_QUATERNION_H__

#define __CGLA_QUATERNION_H__

#include "Vec3f.h"

#include "Vec4f.h"

#include "Mat3x3f.h"

#include "Mat4x4f.h"

namespace CGLA {

	/** \brief A Quaterinion class. 

	Quaternions are algebraic entities useful for rotation. */

	class Quaternion

	{

	public:

		/// Vector part of quaternion

		Vec3f qv;

		/// Scalar part of quaternion

		float qw;

		/// Construct 0 quaternion

		Quaternion(): qw(CGLA_INIT_VALUE) {}

		/// Construct quaternion from vector and scalar

		Quaternion(const Vec3f _qv, float _qw=1) : 

			qv(_qv) , qw(_qw) {}

		/// Construct quaternion from four scalars

		Quaternion(float x, float y, float z, float _qw) : 

			qv(x,y,z), qw(_qw) {}

		/// Assign values to a quaternion

		void set(float x, float y, float z, float _qw) 

		{

			qv.set(x,y,z);

			qw = _qw;

		}

		/// Get values from a quaternion

		void get(float& x, float& y, float& z, float& _qw) const

		{

			x  = qv[0];

			y  = qv[1];

			z  = qv[2];

			_qw = qw;

		}

		/// Get a 3x3 rotation matrix from a quaternion

		Mat3x3f get_mat3x3f() const;

		/// Get a 4x4 rotation matrix from a quaternion

		Mat4x4f get_mat4x4f() const;

		/// Construct a Quaternion from a rotation matrix.

		/// Matrix must be orthogonal

		void make_rot(const Mat4x4f& m);

		/// Construct a Quaternion from an angle and axis of rotation.

		void make_rot(float angle, const Vec3f&);

		/** Construct a Quaternion rotating from the direction given

				by the first argument to the direction given by the second.*/

		void make_rot(const Vec3f&,const Vec3f&);

		/// Obtain angle of rotation and axis

		void get_rot(float& angle, Vec3f&);

		/// Multiply two quaternions. (Combine their rotation)

		Quaternion operator *(Quaternion quat) const;

		/// Multiply scalar onto quaternion.

		Quaternion operator *(float scalar) const;

		/// Add two quaternions.

		Quaternion operator +(Quaternion quat) const;

		/// Invert quaternion

		Quaternion inverse() const;

		/// Return conjugate quaternion

		Quaternion conjugate() const;

		/// Compute norm of quaternion

		float norm() const;

		/// Normalize quaternion.

		Quaternion normalize();

		/// Rotate vector according to quaternion

		Vec3f apply(const Vec3f& vec) const;

	};

	/// Compare for equality.

	inline bool operator==(const Quaternion& q0, const Quaternion& q1)

	{

		return (q0.qw == q1.qw && q0.qv == q1.qv);

	}

	/// Print quaternion to stream.

	inline std::ostream& operator<<(std::ostream&os, const Quaternion v)

	{

		os << "[ ";

		for(unsigned int i=0;i<3;i++) os << v.qv[i] << " ";

		os << " ~ " << v.qw << " ";

		os << "]";

		return os;

	}

	inline Quaternion Quaternion::operator *(Quaternion quat) const

	{

		return Quaternion(cross(qv,quat.qv) + quat.qw*qv + qw*quat.qv, 

											qw*quat.qw - dot(qv,quat.qv));

	}

	inline Quaternion Quaternion::operator *(float scalar) const

	{

		return Quaternion(scalar*qv,scalar*qw);

	}

	/// Multiply scalar onto quaternion

	inline Quaternion operator *(float scalar, Quaternion quat) 

	{

		return Quaternion(scalar*quat.qv,scalar*quat.qw);

	}

	inline Quaternion Quaternion::operator +(Quaternion quat) const

	{

		return Quaternion(qv + quat.qv,qw + quat.qw);

	}

	inline float Quaternion::norm() const

	{

		return qv[0]*qv[0] + qv[1]*qv[1] + qv[2]*qv[2] + qw*qw;

	}

	inline Quaternion Quaternion::normalize() 

	{

		return Quaternion(1.0/norm()*(*this));

	}

	inline Quaternion Quaternion::conjugate() const

	{

		return Quaternion(-qv,qw);

	}

	inline Quaternion Quaternion::inverse() const

	{

		return Quaternion(1.0/norm()*conjugate());

	}

	/** Perform linear interpolation of two quaternions. 

			The last argument is the parameter used to interpolate

			between the two first. SLERP - invented by Shoemake -

			is a good way to interpolate because the interpolation

			is performed on the unit sphere. 	

	*/

	inline Quaternion slerp(Quaternion q0, Quaternion q1, float t) 

	{

		float angle=acos(q0.qv[0]*q1.qv[0]+q0.qv[1]*q1.qv[1]+q0.qv[2]*q1.qv[2]+q0.qw*q1.qw);

		return (q0*sin((1-t)*angle)+q1*sin(t*angle))*(1/sin(angle));

	}

}

#endif