gtc/quaternion.hpp

Go to the documentation of this file.

#ifndef GLM_GTC_quaternion
#define GLM_GTC_quaternion GLM_VERSION

// Dependency:
#include "../glm.hpp"
#include "../gtc/half_float.hpp"

#if(defined(GLM_MESSAGES) && !defined(glm_ext))
#       pragma message("GLM: GLM_GTC_quaternion extension included")
#endif

namespace glm{
namespace detail
{
        template <typename T> 
        struct tquat// : public genType<T, tquat>
        {
                enum ctor{null};

                typedef T value_type;
                typedef std::size_t size_type;

        public:
                value_type x, y, z, w;

                GLM_FUNC_DECL size_type length() const;

                // Constructors
                tquat();
                explicit tquat(
                        value_type const & s, 
                        glm::detail::tvec3<T> const & v);
                explicit tquat(
                        value_type const & w, 
                        value_type const & x, 
                        value_type const & y, 
                        value_type const & z);

                // Convertions

                explicit tquat(
                        tvec3<T> const & eulerAngles);
                explicit tquat(
                        tmat3x3<T> const & m);
                explicit tquat(
                        tmat4x4<T> const & m);

                // Accesses
                value_type & operator[](int i);
                value_type const & operator[](int i) const;

                // Operators
                tquat<T> & operator*=(value_type const & s);
                tquat<T> & operator/=(value_type const & s);
        };

        template <typename T> 
        detail::tquat<T> operator- (
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> operator+ ( 
                detail::tquat<T> const & q, 
                detail::tquat<T> const & p); 

        template <typename T> 
        detail::tquat<T> operator* ( 
                detail::tquat<T> const & q, 
                detail::tquat<T> const & p); 

        template <typename T> 
        detail::tvec3<T> operator* (
                detail::tquat<T> const & q, 
                detail::tvec3<T> const & v);

        template <typename T> 
        detail::tvec3<T> operator* (
                detail::tvec3<T> const & v,
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tvec4<T> operator* (
                detail::tquat<T> const & q, 
                detail::tvec4<T> const & v);

        template <typename T> 
        detail::tvec4<T> operator* (
                detail::tvec4<T> const & v,
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> operator* (
                detail::tquat<T> const & q, 
                typename detail::tquat<T>::value_type const & s);

        template <typename T> 
        detail::tquat<T> operator* (
                typename detail::tquat<T>::value_type const & s,
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> operator/ (
                detail::tquat<T> const & q, 
                typename detail::tquat<T>::value_type const & s);

} //namespace detail


        template <typename T> 
        T length(
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> normalize(
                detail::tquat<T> const & q);
                
        template <typename T> 
        T dot(
                detail::tquat<T> const & q1, 
                detail::tquat<T> const & q2);

        template <typename T> 
        detail::tquat<T> mix(
                detail::tquat<T> const & x, 
                detail::tquat<T> const & y, 
                T const & a);
                
        template <typename T> 
        detail::tquat<T> conjugate(
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> inverse(
                detail::tquat<T> const & q);

        template <typename T> 
        detail::tquat<T> rotate(
                detail::tquat<T> const & q, 
                typename detail::tquat<T>::value_type const & angle, 
                detail::tvec3<T> const & axis);

        template <typename T> 
        detail::tvec3<T> eulerAngles(
                detail::tquat<T> const & x);

        template <typename T> 
        detail::tmat3x3<T> mat3_cast(
                detail::tquat<T> const & x);

        template <typename T> 
        detail::tmat4x4<T> mat4_cast(
                detail::tquat<T> const & x);

        template <typename T> 
        detail::tquat<T> quat_cast(
                detail::tmat3x3<T> const & x);

        template <typename T> 
        detail::tquat<T> quat_cast(
                detail::tmat4x4<T> const & x);

        template <typename valType> 
        valType angle(
                detail::tquat<valType> const & x);

        template <typename valType> 
        detail::tvec3<valType> axis(
                detail::tquat<valType> const & x);

        template <typename valType> 
        detail::tquat<valType> angleAxis(
                valType const & angle, 
                valType const & x, 
                valType const & y, 
                valType const & z);

        template <typename valType> 
        detail::tquat<valType> angleAxis(
                valType const & angle, 
                detail::tvec3<valType> const & axis);

        typedef detail::tquat<float> quat;

        typedef detail::tquat<detail::half>     hquat;

        typedef detail::tquat<float>    fquat;

        typedef detail::tquat<double>   dquat;

        typedef detail::tquat<lowp_float>               lowp_quat;

        typedef detail::tquat<mediump_float>    mediump_quat;

        typedef detail::tquat<highp_float>              highp_quat;

} //namespace glm

#include "quaternion.inl"

#endif//GLM_GTC_quaternion