_Euler4.h

Go to the documentation of this file.

#ifndef __VECMATH_EULER4_HPP
#define __VECMATH_EULER4_HPP

// directly based upon the code from GemsIV (p.224)
//

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

template <class Type> class _Euler4;

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

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

#ifndef __VECMATH_MATRIX4_HPP
#include <vecmath/_Matrix4.h>
#endif

typedef int order_t;

//#define DEBUGEULER4(d) d
#define DEBUGEULER4(d)

#define EulSafe      "\000\001\002\000"
#define EulNext      "\001\002\000\001"
#define EulFrm(ord) ((unsigned)(ord)&1)
#define EulRep(ord) (((unsigned)(ord)>>1)&1)
#define EulPar(ord) (((unsigned)(ord)>>2)&1)
#define EulOrd(i, p, r, f) (((((((i)<<1)+(p))<<1)+(r))<<1)+(f))
#define EulGetOrd(ord,i,j,k,h,n,s,f) {unsigned o=ord;f=o&1;o>>=1;s=o&1;o>>=1;\
    n=o&1;o>>=1;i=EulSafe[o&3];j=EulNext[i+n];k=EulNext[i+1-n];h=s?k:i;}

//template <class Type> ostream& operator <<(ostream& os, const _Euler4<Type>& t);
//template <class Type> ostream& operator <<(ostream& os, const _Euler4<Type>* t);

template <class Type> class VECMATH_EXPORT _Euler4 {
public:
    enum { X, Y, Z, W };
    static const order_t EulFrmS = 0;
    static const order_t EulFrmR = 1;
    static const order_t EulRepNo = 0;
    static const order_t EulRepYes = 1;
    static const order_t EulParEven = 0;
    static const order_t EulParOdd = 1;

    /* Static axes */
    static const order_t EulOrdXYZs = EulOrd(X,EulParEven,EulRepNo,EulFrmS);
    static const order_t EulOrdXYXs = EulOrd(X,EulParEven,EulRepYes,EulFrmS);
    static const order_t EulOrdXZYs = EulOrd(X,EulParOdd,EulRepNo,EulFrmS);
    static const order_t EulOrdXZXs = EulOrd(X,EulParOdd,EulRepYes,EulFrmS);
    static const order_t EulOrdYZXs = EulOrd(Y,EulParEven,EulRepNo,EulFrmS);
    static const order_t EulOrdYZYs = EulOrd(Y,EulParEven,EulRepYes,EulFrmS);
    static const order_t EulOrdYXZs = EulOrd(Y,EulParOdd,EulRepNo,EulFrmS);
    static const order_t EulOrdYXYs = EulOrd(Y,EulParOdd,EulRepYes,EulFrmS);
    static const order_t EulOrdZXYs = EulOrd(Z,EulParEven,EulRepNo,EulFrmS);
    static const order_t EulOrdZXZs = EulOrd(Z,EulParEven,EulRepYes,EulFrmS);
    static const order_t EulOrdZYXs = EulOrd(Z,EulParOdd,EulRepNo,EulFrmS);
    static const order_t EulOrdZYZs = EulOrd(Z,EulParOdd,EulRepYes,EulFrmS);
    /* Rotating axes */
    static const order_t EulOrdZYXr = EulOrd(X,EulParEven,EulRepNo,EulFrmR);
    static const order_t EulOrdXYXr = EulOrd(X,EulParEven,EulRepYes,EulFrmR);
    static const order_t EulOrdYZXr = EulOrd(X,EulParOdd,EulRepNo,EulFrmR);
    static const order_t EulOrdXZXr = EulOrd(X,EulParOdd,EulRepYes,EulFrmR);
    static const order_t EulOrdXZYr = EulOrd(Y,EulParEven,EulRepNo,EulFrmR);
    static const order_t EulOrdYZYr = EulOrd(Y,EulParEven,EulRepYes,EulFrmR);
    static const order_t EulOrdZXYr = EulOrd(Y,EulParOdd,EulRepNo,EulFrmR);
    static const order_t EulOrdYXYr = EulOrd(Y,EulParOdd,EulRepYes,EulFrmR);
    static const order_t EulOrdYXZr = EulOrd(Z,EulParEven,EulRepNo,EulFrmR);
    static const order_t EulOrdZXZr = EulOrd(Z,EulParEven,EulRepYes,EulFrmR);
    static const order_t EulOrdXYZr = EulOrd(Z,EulParOdd,EulRepNo,EulFrmR);
    static const order_t EulOrdZYZr = EulOrd(Z,EulParOdd,EulRepYes,EulFrmR);

    static const Type EPS;// = 1.0e-06;
    static const Type EPS1;// = 1.0e-30;
    Type x, y, z;
    order_t order;

    _Euler4<Type>() {}

    explicit _Euler4<Type>(Type x, Type y = 0, Type z = 0, order_t order = EulOrdXYZs) : x(x), y(y), z(z), order(order) {
        DEBUGEULER4(cout << "_Euler4 explicit constructor x,y,z,w " << *this << endl);
    }

    _Euler4<Type>(const _Tuple4<double>& t) {
        set(t);
        DEBUGEULER4(cout << "_Euler4 constructor &double " << *this << endl);
    }

    _Euler4<Type>(const _Tuple4<float>& t) {
        set(t);
        DEBUGEULER4(cout << "_Euler4 constructor &float " << *this << endl);
    }

    _Euler4<Type>(const Type t[4]) {
        set(t);
        DEBUGEULER4(cout << "_Euler4 constructor t[4] " << *this << endl);
    }


    void get(_Matrix4<double>& m) const;
    void get(_Matrix4<float>& m) const;
    void get(_Matrix3<double>& m) const;
    void get(_Matrix3<float>& m) const;

    void get(_Quat4<double>& q) const;

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

    void interpolate(const _Euler4<Type>& q, const _Euler4<Type>& q1, Type d) {}

    void set(Type _x, Type _y = 0.0, Type _z = 0.0, order_t _order = EulOrdXYZs) {
        x = _x;
        y = _y;
        z = _z;
        order = _order;
    }

    void set(const _Tuple4<double>& t) {
        set(t.x, t.y, t.z, (order_t) t.w);
    }

    void set(const _Tuple4<float>& t) {
        set(t.x, t.y, t.z, (order_t) t.w);
    }

    void set(const _Quat4<float>& m) {
        //FIXME
    }

    void set(const double v[4]) {
        set(v[0], v[1], v[2], (order_t) v[3]);
    }

    void set(const float v[4]) {
        set(v[0], v[1], v[2], (order_t) v[3]);
    }

    void set(const _Matrix4<double>& m, order_t _order = EulOrdXYZs);
    void set(const _Matrix4<float>& m, order_t _order = EulOrdXYZs);
    void set(const _Matrix3<double>& m, order_t _order = EulOrdXYZs);
    void set(const _Matrix3<float>& m, order_t _order = EulOrdXYZs);

    void set(const _Euler4<double>& e) {
        set(e.x, e.y, e.z, e.order);
    }

    void set(const _Euler4<float>& e) {
        set(e.x, e.y, e.z, e.order);
    }

//    friend ostream & operator << <>( ostream &, const _Euler4<Type> & );
//    friend ostream & operator << <>( ostream &, const _Euler4<Type> * );

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

---