_Tuple4.h

Go to the documentation of this file.

#ifndef __VECMATH_TUPLE4_HPP
#define __VECMATH_TUPLE4_HPP

#ifndef __VECMATH_TUPLE3_HPP
#include <vecmath/_Tuple3.h>
#endif

//#define DEBUGTUPLE4(d) d
#define DEBUGTUPLE4(d)

// General template for Tuple4
// (used by Tuple4f, Tuple4d, Point4d, Point4d, Vector4f, Vector4d)
//
// for standard functions see documentation for Java3D
//
// all standard overload operation are support as well
//

//template <class Type> class _Tuple4;

//template <class Type> ostream& operator <<(ostream&, const _Tuple4<Type>&);
//template <class Type> ostream& operator <<(ostream&, const _Tuple4<Type>*);


template <class Type> class VECMATH_EXPORT _Tuple4 {
public:
    Type x, y, z, w;

    _Tuple4<Type>() {}

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

    _Tuple4<Type>(const _Tuple4<byte>& t) {
        set(t);
        DEBUGTUPLE4(cout << "_Tuple4 constructor &byte " << *this << endl);
    }

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

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

    _Tuple4<Type>(const _Tuple3<byte>& t) {
        set(t);
        DEBUGTUPLE4(cout << "_Tuple4 constructor &byte3 " << *this << endl);
    }

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

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

    _Tuple4<Type>(const _Tuple3<int>& t) {
        set(t);
        DEBUGTUPLE4(cout << "_Tuple4 constructor &int3 " << *this << endl);
    }

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

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

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

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

    ~_Tuple4<Type>() {
        DEBUGTUPLE4(cout << "_Tuple4 destructor " << *this << endl);
    }

    void add(const _Tuple4<Type>& t) {
        x += t.x;
        y += t.y;
        z += t.z;
        w += t.w;
    }

    void add(const _Tuple4<Type>& t, const _Tuple4<Type>& t1) {
        x = t.x + t1.x;
        y = t.y + t1.y;
        z = t.z + t1.z;
        w = t.w + t1.w;
    }

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

    void absolute(const _Tuple4<Type>& t) {
        DEBUGTUPLE4(cout << "_Tuple4 absolute(t) " << *this << " = ");
        set(Math::abs(t.x), Math::abs(t.y), Math::abs(t.z), Math::abs(t.w));
        DEBUGTUPLE4(cout << *this << endl);
    }

    void clamp(Type min, Type max) {
        DEBUGTUPLE4(cout << "_Tuple4 clamp(" << min << ", " << max << ") = " << *this << endl);
        clamp(min, max, *this);
    }

    void clampMin(Type min) {
        DEBUGTUPLE4(cout << "_Tuple4 clampMin(" << min << ") = " << *this << endl);
        clampMax(min, *this);
    }

    void clampMax(Type max) {
        DEBUGTUPLE4(cout << "_Tuple4 clampMax(" << max << ") = " << *this << endl);
        clampMax(max, *this);
    }

    void clamp(Type min, Type max, const _Tuple4<Type> &t);
    void clampMin(Type min, const _Tuple4<Type> &t);
    void clampMax(Type min, const _Tuple4<Type> &t);

    void get(byte t[4]) const {
        t[0] = (byte) x;
        t[1] = (byte) y;
        t[2] = (byte) z;
        t[3] = (byte) w;
    }

    void get(double t[4]) const {
        t[0] = x;
        t[1] = y;
        t[2] = z;
        t[3] = w;
    }

    void get(float t[4]) const {
        t[0] = x;
        t[1] = y;
        t[2] = z;
        t[3] = w;
    }

    void get(_Tuple4<Type> &t) const {
        t.x = x; t.y = y; t.z = z; t.w = w;
    }

    bool equals(const _Tuple4<Type> &t) const {
        DEBUGTUPLE4(cout << "_Tuple4 epsilon() " << *this << endl);
        return (x == t.x && y == t.y && z == t.z && z == t.z);
    }

    bool epsilonEquals(const _Tuple4<Type> &t, Type epsilon) const {
        DEBUGTUPLE4(cout << "_Tuple4 epsilonEquals() " << *this << endl);
        // FIX - use MATH
        return (Math::epsilonEquals(x, t.x, epsilon)
                && Math::epsilonEquals(y, t.y, epsilon)
                && Math::epsilonEquals(z, t.z, epsilon)
                && Math::epsilonEquals(w, t.w, epsilon));
    }

    void interpolate(_Tuple4<Type> &t, double alpha) {
        interpolate(*this, t, alpha);
    }

    void interpolate(_Tuple4<Type> &t1, const _Tuple4<Type> &t2, double alpha);

    void negate(void) {
        x = -x; y = -y; z = -z; w = -w;
    }

    void negate(const _Tuple4<Type> &t) {
        x = -t.x; y = -t.y; z = -t.z; w = -t.z;
    }

    // extension
    Type normSquared() const {
        return (Type) (Math::sqr(x) + Math::sqr(y) + Math::sqr(z) + Math::sqr(w));
    }

    // extension
    Type norm() const {
        return (Type) sqrt(normSquared());
    }

    void scale(Type s) {
        x *= s;
        y *= s;
        z *= s;
        w *= s;
    }

    void scaleAdd(Type s, const _Tuple4<Type> &t) {
        scaleAdd(s, *this, t);
    }

    void scaleAdd(Type s, const _Tuple4<Type> &t1, const _Tuple4<Type> &t2) {
        x = s * t1.x + t2.x;
        y = s * t1.y + t2.y;
        z = s * t1.z + t2.z;
        w = s * t1.w + t2.w;
    }

    void set(Type xx = 0, Type yy = 0, Type zz = 0, Type ww = 0) {
        x = xx, y = yy, z = zz, w = ww;
    }

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

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

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

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

    void set(const _Tuple3<byte>& t) {
        set(Type(t.x), Type(t.y), Type(t.z));
    }

    void set(const _Tuple3<float>& t) {
        set(Type(t.x), Type(t.y), Type(t.z));
    }

    void set(const _Tuple3<double>& t) {
        set(Type(t.x), Type(t.y), Type(t.z));
    }

    void set(const _Tuple3<int>& t) {
        set(Type(t.x), Type(t.y), Type(t.z));
    }

    void set(const byte t[4]) {
        set(Type(t[0]), Type(t[1]), Type(t[2]), Type(t[3]));
    }

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

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

    void set(const int t[4]) {
        set(Type(t[0]), Type(t[1]), Type(t[2]), Type(t[3]));
    }

    void sub(const _Tuple4<Type>& t) {
        x -= t.x;
        y -= t.y;
        z -= t.z;
        w -= t.w;
    }

    void sub(const _Tuple4<Type>& t1, const _Tuple4<Type>& t2) {
        x = t1.x - t2.x;
        y = t1.y - t2.y;
        z = t1.z - t2.z;
        w = t1.w - t2.w;
    }

#if 0   
    String &toString(String &s);
#endif

// non Java3D extensions

    // assignment

//      _Tuple4<Type>& operator =(const _Tuple4<Type>& v) {
//      cout << "_Tuple4 operator = _Tuple4" << endl;
//      x = v.x; y = v.y; z = v.z;
//      return *this;
//      }

    // math operators

    _Tuple4<Type>& operator +=(const _Tuple4<Type>& t) {
        add(t);
        DEBUGTUPLE4(cout << "_Tuple4 operator+= _Tuple4 " << *this  << endl);
        return *this;
    }

    _Tuple4<Type>& operator -=(const _Tuple4<Type>& t) {
        sub(t);
        DEBUGTUPLE4(cout << "_Tuple4 operator-= _Tuple4 " << *this  << endl);
        return *this;
    }

    _Tuple4<Type>& operator *=(Type c) {
        scale(c);
        DEBUGTUPLE4(cout << "_Tuple4 operator*= _Tuple4 " << *this  << endl);
        return *this;
    }

    _Tuple4<Type>& operator /=(Type c) {
        // FIXME assert zero test
        x /= c; y /= c; z /= c; w /= c;
        DEBUGTUPLE4(cout << "_Tuple4 operator/= _Tuple4 " << *this  << endl);
        return *this;
    }

    _Tuple4<Type> operator -() const {
        DEBUGTUPLE4(cout << "_Tuple4 operator- ()" << *this << " = " << _Tuple4<Type>(-x, -y, -z) << endl);
        return _Tuple4<Type>(-x, -y, -z, -z);
    }

    _Tuple4<Type> operator +(const _Tuple4<Type>& t) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator+ _Tuple4 " << *this << endl);
        return _Tuple4<Type>(*this) += t;
    }

    _Tuple4<Type> operator -(const _Tuple4<Type>& t) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator- _Tuple4 " << *this << endl);
        return _Tuple4<Type>(*this) -= t;
    }

    _Tuple4<Type> operator *(Type c) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator* " << *this << " * " << c << endl);
        return _Tuple4<Type>(*this) *= c;
    }

    _Tuple4<Type> operator /(Type c) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator/ " << *this << " / " << c <<  endl);
        return _Tuple4<Type>(*this) /= c;
    }

    bool operator ==(const _Tuple4<Type>& t) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator== _Tuple4 " << *this << endl);
        return (epsilonEquals(t, (Type) Math::EPSILON));
    }

    bool operator !=(const _Tuple4<Type>& t) const {
        DEBUGTUPLE4(cout << "_Tuple4 operator!= _Tuple4 " << *this << endl);
        return (!(*this == t));
    }

    Type& operator [](int i) const {
        return (Type&) (operator const Type *())[i];
    }

    operator const Type * () const {
        return &x;
    }

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

#endif

---