_Quat4.h

Go to the documentation of this file.

#ifndef __VECMATH_QUAT4_HPP
#define __VECMATH_QUAT4_HPP

#ifndef __LANG_MATH_HPP
#include <vecmath/Math.h>
#endif

template <class Type> class _Quat4;

#ifndef __VECMATH_TUPLE4_HPP
#include <vecmath/_Tuple4.h>
#endif

//#ifndef __VECMATH_AXISANGLE_HPP
//#include <vecmath/_AxisAngle4.h>
//#endif

//#define DEBUGQUAT4(d) d
#define DEBUGQUAT4(d)

template <class Type> class VECMATH_EXPORT _Quat4 : public _Tuple4<Type> {
public:
    static const Type EPS;// = 1.0e-06;
    static const Type EPS1;// = 1.0e-30;

    _Quat4<Type>() : _Tuple4<Type>() {}

    explicit _Quat4<Type>(Type x, Type y = 0, Type z = 0, Type w = 1.0) : _Tuple4<Type>(x,y,z,w) {
        normalize();
        DEBUGQUAT4(cout << "_Quat4 explicit constructor x,y,z,w " << *this << endl);
    }

    _Quat4<Type>(const _Tuple4<double>& t) : _Tuple4<Type>(t) {
        normalize();
        DEBUGQUAT4(cout << "_Quat4 constructor &double " << *this << endl);
    }

    _Quat4<Type>(const _Tuple4<float>& t) : _Tuple4<Type>(t) {
        normalize();
        DEBUGQUAT4(cout << "_Quat4 constructor &float " << *this << endl);
    }

    _Quat4<Type>(const Type t[4]) : _Tuple4<Type>(t) {
        normalize();
        DEBUGQUAT4(cout << "_Quat4 constructor t[4] " << *this << endl);
    }

    void conjugate() {
        conjugate(*this);
    }

    void conjugate(const _Quat4<Type>& q) {
        _Tuple4<Type>::x = -q.x;
        _Tuple4<Type>::y = -q.y;
        _Tuple4<Type>::z = -q.z;
        _Tuple4<Type>::w = q.w;
    }

    // extension
    //void getEuler(const _Vector3<Type>& v) {
        //FIXME
    //}


    void interpolate(const _Quat4<Type>& q, Type d) {
        interpolate(*this, q, d);
    }

    void interpolate(const _Quat4<Type>& q, const _Quat4<Type>& q1, Type d);

    void inverse() {
        inverse(*this);
    }

    void inverse(const _Quat4<Type>& q) {
        normalize();
        conjugate();
    }

    void mul(const _Quat4<Type>& q) {
        mul(*this, q);
    }

    void mul(const _Quat4<Type>& q, const _Quat4<Type>& q1);

    void mulInverse(const _Quat4<Type>& q) {
        mulInverse(*this, q);
    }

    void mulInverse(const _Quat4<Type>& q, const _Quat4<Type>& q1) {
        _Quat4<Type> q2(q1);
        q2.inverse();
        mul(q, q2);
    }

    void normalize() {
        normalize(*this);
    }

    void normalize(const _Quat4<Type>& q) {
        Type d = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
        if(d > 0.0) {
            d = sqrt(d);
            _Tuple4<Type>::set(q.x / d, q.y / d, q.z / d, q.w / d);
        } else
            _Tuple4<Type>::set(0.0, 0.0, 0.0, 0.0);
    }

#if 0
    void set(const _AxisAngle4<double>& a) {
        setByAxis(a.x, a.y, a.z, a.angle);
    }

    void set(const _AxisAngle4<float>& a) {
        setByAxis(a.x, a.y, a.z, a.angle);
    }
#endif

#if 0
    void set(const _Matrix3<double>& m) {
        setByMatrix(m.m00, m.m01, m.m02,
                    m.m10, m.m11, m.m12,
                    m.m20, m.m21, m.m22);
    }

    void set(const _Matrix3<float>& m) {
        setByMatrix(m.m00, m.m01, m.m02,
                    m.m10, m.m11, m.m12,
                    m.m20, m.m21, m.m22);
    }

    // extension
    void set(const double m[9]) {
        setByMatrix(m[0], m[1], m[2],
                    m[3], m[4], m[5],
                    m[6], m[7], m[8]);
    }

    void set(const _Matrix4<double>& m) {
        setByMatrix(m.m00, m.m01, m.m02,
                    m.m10, m.m11, m.m12,
                    m.m20, m.m21, m.m22);
    }

    void set(const _Matrix4<float>& m) {
        setByMatrix(m.m00, m.m01, m.m02,
                    m.m10, m.m11, m.m12,
                    m.m20, m.m21, m.m22);
    }
#endif

    void set(const _Quat4<double>& q) {
        _Tuple4<Type>::set(q.x, q.y, q.z, q.w);
    }

    void set(const _Quat4<float>& q) {
        _Tuple4<Type>::set(q.x, q.y, q.z, q.w);
    }

private:
    void setByMatrix(double m00, double m01, double m02,
                     double m10, double m11, double m12,
                     double m20, double m21, double m22);

    void setByAxis(double ax, double ay, double az, double aa);
};

#endif

---