---

QuatC.h

//-------------------------------------------------------------------------
//
// File:        QuatC.h
// Desc:        Quaternion class.
// Author:      memon <memon@inside.org>
//
//-------------------------------------------------------------------------
//  Copyright (c) 2000-2002 Moppi Productions. All Rights Reserved.
//  This file is part of Moppi Demopaja SDK. For conditions of 
//  distribution and use, see the accompanying license.txt file.
//  http://moppi.inside.org/demopaja/
//-------------------------------------------------------------------------

#ifndef __DEMOPAJA_QUATC_H__
#define __DEMOPAJA_QUATC_H__

#include "PajaTypes.h"
#include "Vector3C.h"
#include "Matrix3C.h"

namespace PajaTypes {

    class Matrix3C;


    class QuatC {
    public:
        QuatC( float32 f32X = 0, float32 f32Y = 0, float32 f32Z = 0, float32 f32W = 1 );

        QuatC( const QuatC& rQuat );

        virtual ~QuatC();

        void            from_rot_matrix( const Matrix3C& rMat );

        Matrix3C        to_rot_matrix() const;

        void            from_axis_angle( const Vector3C& rVec, float32 f32Angle );

        void            from_axis_angle( float32 f32X, float32 f32Y, float32 f32Z, float32 f32Angle );

        void            to_axis_angle( Vector3C& rVec, float32& f32Angle ) const;

        void            to_axis_angle( float32& f32X, float32& f32Y, float32& f32Z, float32& f32Angle ) const;

        QuatC           operator-() const;


        float32&        operator[]( int32 i );


        const float32&  operator[]( int32 i ) const;

        QuatC           operator+( const QuatC& rQuat ) const;

        QuatC           operator-( const QuatC& rQuat ) const;

        QuatC           operator*( const QuatC& rQuat ) const;

        QuatC           operator/( const QuatC& rQuat ) const;

        QuatC           operator*( float32 f32Scalar ) const;

        friend QuatC    operator*( float32 f32Scalar, const QuatC& rQuat );
  
        bool            operator==( const QuatC& rQuat ) const;

        bool            operator!=( const QuatC& rQuat ) const;

        float32         dot( const QuatC& rQuat ) const;

        float32         norm() const;


        QuatC           inverse() const;


        QuatC           unit_inverse() const;

        QuatC           exp() const;

        QuatC           log() const;

        QuatC           normalize() const;


        static QuatC    slerp( float32 f32T, const QuatC& rQ, const QuatC& rP );


    private:
        float32 m_f32Quat[4];

    };


    //
    //
    // inlines
    //
    //

    inline
    float32&
    QuatC::operator[]( int32 i )
    {
        assert( i >= 0 && i < 4 );
        return m_f32Quat[i];
    }

    inline
    const float32&
    QuatC::operator[]( int32 i ) const
    {
        assert( i >= 0 && i < 4 );
        return m_f32Quat[i];
    }

    inline
    bool
    QuatC::operator==( const QuatC& a ) const
    {
        return (m_f32Quat[0] == a.m_f32Quat[0]) &&
               (m_f32Quat[1] == a.m_f32Quat[1]) &&
               (m_f32Quat[2] == a.m_f32Quat[2]) &&
               (m_f32Quat[3] == a.m_f32Quat[3]);
    }

    inline
    bool
    QuatC::operator!=( const QuatC& a ) const
    {
        return (m_f32Quat[0] != a.m_f32Quat[0]) ||
               (m_f32Quat[1] != a.m_f32Quat[1]) ||
               (m_f32Quat[2] != a.m_f32Quat[2]) ||
               (m_f32Quat[3] != a.m_f32Quat[3]);
    }

    inline
    QuatC
    QuatC::operator+( const QuatC& rQuat ) const
    {
        return QuatC( m_f32Quat[0] + rQuat.m_f32Quat[0],
                      m_f32Quat[1] + rQuat.m_f32Quat[1],
                      m_f32Quat[2] + rQuat.m_f32Quat[2],
                      m_f32Quat[3] + rQuat.m_f32Quat[3] );
    }

    inline
    QuatC
    QuatC::operator-( const QuatC& rQuat ) const
    {
        return QuatC( m_f32Quat[0] - rQuat.m_f32Quat[0],
                      m_f32Quat[1] - rQuat.m_f32Quat[1],
                      m_f32Quat[2] - rQuat.m_f32Quat[2],
                      m_f32Quat[3] - rQuat.m_f32Quat[3] );
    }

    inline
    QuatC
    QuatC::operator*( float32 f32Scalar ) const
    {
        return QuatC( m_f32Quat[0] * f32Scalar,
                      m_f32Quat[1] * f32Scalar,
                      m_f32Quat[2] * f32Scalar,
                      m_f32Quat[3] * f32Scalar );
    }

    inline
    QuatC
    operator*( float32 f32Scalar, const QuatC& rQuat )
    {
        return QuatC( rQuat[0] * f32Scalar,
                      rQuat[1] * f32Scalar,
                      rQuat[2] * f32Scalar,
                      rQuat[3] * f32Scalar );
    }

    inline
    QuatC
    QuatC::operator-() const
    {
        QuatC   rRes = *this; //->normalize();
        rRes = rRes.normalize();
        return QuatC( -rRes.m_f32Quat[0],
                      -rRes.m_f32Quat[1],
                      -rRes.m_f32Quat[2],
                       rRes.m_f32Quat[3] );
    }

    inline
    float32
    QuatC::dot( const QuatC& rQuat ) const
    {
        return m_f32Quat[0] * rQuat.m_f32Quat[0] +
               m_f32Quat[1] * rQuat.m_f32Quat[1] +
               m_f32Quat[2] * rQuat.m_f32Quat[2] +
               m_f32Quat[3] * rQuat.m_f32Quat[3];
    }

    inline
    float32
    QuatC::norm() const
    {
        return m_f32Quat[0] * m_f32Quat[0] +
               m_f32Quat[1] * m_f32Quat[1] +
               m_f32Quat[2] * m_f32Quat[2] +
               m_f32Quat[3] * m_f32Quat[3];
    }


    inline
    QuatC
    QuatC::unit_inverse() const
    {
        return QuatC( -m_f32Quat[0], -m_f32Quat[1], -m_f32Quat[2], m_f32Quat[3]);
    }


}

#endif

---