---

quaternion.h

//FILE:         quaternion.h
//AUTHOR:       Nathan Cournia <nathan@cournia.com>
//NOTE:         Not by any means a complete implementaion.

#ifndef COURNIA_QUATERNION_H
#define COURNIA_QUATERNION_H 1

#include <iostream>
#include <cmath>
#include "vector.h"
#include "matrix.h"

namespace math {
        class quaternion;
}

std::ostream& operator<< ( std::ostream& o, const math::quaternion& q );


class math::quaternion {
private:
        math::vector3 m_v;
        real_t m_w;


        friend std::ostream& operator<< ( std::ostream& o, const math::quaternion& vec );

public:

        quaternion( void ): m_w( 1.0 ) 
        { }


        quaternion( const math::vector3& v_, real_t w_ ): m_v( v_ ), m_w( w_ ) 
        { }


        quaternion( real_t x_, real_t y_, real_t z_, real_t w_ ):
                m_v( x_, y_, z_ ), m_w( w_ ) 
        { }

        quaternion( const math::quaternion& p ): m_v( p.m_v ), m_w( p.m_w )  
        { }

        inline math::quaternion& operator= ( const math::quaternion& p ) {
                m_v = p.m_v;
                m_w = p.m_w;
                return *this;
        }

        inline real_t w( void ) const { 
                return m_w; 
        }

        inline real_t x( void ) const { 
                return m_v.x( ); 
        }

        inline real_t y( void ) const { 
                return m_v.y( ); 
        }

        inline real_t z( void ) const { 
                return m_v.z( ); 
        }


        inline math::vector3 v( void ) const { 
                return m_v; 
        }


        inline math::vector3 vec( void ) const { 
                return m_v; 
        }


        inline real_t scalar( void ) const { 
                return m_w; 
        }


        inline void set( real_t x_, real_t y_, real_t z_, real_t w_ ) {
                m_v.set( x_, y_, z_ );
                m_w = w_;
        }


        inline void
        set( const math::vector3& v_,  real_t w_ ) {
                m_v = v_;
                m_w = w_;
        }


        inline math::quaternion conjugate( void ) const {
                return math::quaternion( -1.0 * m_v, m_w );
        }


        inline math::quaternion operator! ( void ) const {
                return math::quaternion( -1.0 * m_v, m_w );
        }


        inline double
        magnitude( void ) const {
                return sqrt( (double)(m_w * m_w + math::dot( m_v, m_v )) );
        }


        inline void
        normalize( void ) {
                double mag = magnitude( );
                m_w /= mag;
                m_v.x( m_v.x( ) / mag );
                m_v.y( m_v.y( ) / mag );
                m_v.z( m_v.z( ) / mag );
        }


        void
        set_identity( void ) {
                m_w = 1.0;
                m_v.set( 0.0, 0.0, 0.0 );
        }


        math::matrix4
        get_rotation_matrix( void ) const;


        void
        get_rotation_matrix( math::matrix4& m ) const;


        math::matrix4
        get_transposed_rotation_matrix( void ) const;


        void
        get_transposed_rotation_matrix( math::matrix4& m ) const;

        math::quaternion 
        operator* ( const math::quaternion& rhs ) const;


        math::vector3 
        operator* ( const math::vector3& rhs ) const;


        void
        from_angle_axis( real_t radians, const math::vector3& axis );


        void
        get_angle_axis( real_t& radians, math::vector3& axis ) const;


        static math::quaternion
        slerp( real_t percent, const math::quaternion& qa, 
                const math::quaternion& qb );

        

        static const math::quaternion IDENTITY;
}; //end of class math::quaternion

#endif

---