Quaternion.hpp

#pragma once
#ifndef __H__OCULAR_MATH_QUATERNION__H__
#define __H__OCULAR_MATH_QUATERNION__H__

#include "MathCommon.hpp"
#include "Utilities/Types.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        template<typename T> class Vector3;
        template<typename T> class Vector4;

        class Euler;
        class Matrix3x3;
        class Matrix4x4;

        struct Quaternion_Internal;

        class Quaternion
        {
        public:

            //------------------------------------------------------------------------------
            // CONSTRUCTORS
            //------------------------------------------------------------------------------

            Quaternion(float w, float x, float y, float z);
            
            Quaternion(float angle, Vector3<float> const& axis);
            
            Quaternion(Euler const& euler);
            
            Quaternion(Vector3<float> const& euler);

            Quaternion(Matrix3x3 const& matrix);

            Quaternion(Matrix4x4 const& matrix);


            Quaternion(Quaternion_Internal const& data);

            Quaternion(Quaternion const& other);

            Quaternion();

            ~Quaternion();

            //------------------------------------------------------------------------------
            // OPERATORS
            //------------------------------------------------------------------------------

            Quaternion& operator=(Quaternion const& rhs);
            Quaternion& operator+=(Quaternion const& rhs);
            Quaternion& operator*=(Quaternion const& rhs);
            Quaternion& operator*=(float rhs);
            Quaternion& operator/=(float rhs);

            //------------------------------------------------------------------------------
            // GETTERS / SETTERS
            //------------------------------------------------------------------------------

            float& w();

            float& x();

            float& y();

            float& z();


            //------------------------------------------------------------------------------
            // GENERAL OPERATIONS
            //------------------------------------------------------------------------------

            float dot(Quaternion const& rhs);

            void inverse();

            Quaternion getInverse() const;

            Quaternion getConjugate() const;

            void normalize();

            Quaternion getNormalized() const;

            float getLength() const;
            
            float getYaw() const;
            
            float getPitch() const;
            
            float getRoll() const;

            float getAngle() const;
            
            Vector3<float> getAxis() const;
            
            Quaternion cross(Quaternion const& rhs) const;

            //------------------------------------------------------------------------------
            // STATIC OPERATIONS
            //------------------------------------------------------------------------------

            static Quaternion CreateLookAtRotation(Vector3<float> const& from, Vector3<float> const& to, Vector3<float> const& up);

            static Quaternion Rotate(Quaternion const& source, float angle, Vector3<float> const& axis);

            static Quaternion Mix(Quaternion const& a, Quaternion const& b, float f);

            static Quaternion Lerp(Quaternion const& a, Quaternion const& b, float f);
            
            static Quaternion Slerp(Quaternion const& a, Quaternion const& b, float f);
            
            static Quaternion Bilerp(Quaternion const& q00, Quaternion const& q10, Quaternion const& q01, Quaternion const& q11, float x, float y);

            //------------------------------------------------------------------------------
            // MISC
            //------------------------------------------------------------------------------

            Quaternion_Internal* getInternal() const;

        protected:

            Quaternion_Internal* m_Internal;

        private:

        };

        bool operator==(Quaternion const& lhs, Quaternion const& rhs);
        bool operator!=(Quaternion const& lhs, Quaternion const& rhs);

        Quaternion operator+(Quaternion const& lhs, Quaternion const& rhs);
        Quaternion operator*(Quaternion const& lhs, Quaternion const& rhs);
        Quaternion operator*(Quaternion const& lhs, float rhs);
        Quaternion operator/(Quaternion const& lhs, float rhs);

        Vector3<float> operator*(Quaternion const& lhs, Vector3<float> const& rhs);
        Vector4<float> operator*(Quaternion const& lhs, Vector4<float> const& rhs);
    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Quaternion, "Quaternion");

//------------------------------------------------------------------------------------------

#endif