_Tuple2.h

Go to the documentation of this file.

#ifndef __VECMATH_TUPLE2_HPP
#define __VECMATH_TUPLE2_HPP

#include <stdio.h>
#include <iostream>

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

#include <vecmath/String.h>

//#define DEBUGTUPLE2(d) d
#define DEBUGTUPLE2(d)


// general template for Tuple2
// (used by Tuple2f, Tuple2d, Vector2f, Vector2d, Point2d, Point2f)
//
// for standard functions see documentation for Java3D
//
// all standard overloaded operation are also support
//

// predeclare _Tuple2
template <class Type> class _Tuple2;

// now use predeclared _Tuple2 to predeclare friend operator<<
template <class Type> _Tuple2<Type> operator *(Type c, const _Tuple2<Type>& t);
//template <class Type> ostream& operator <<(ostream& os, const _Tuple2<Type>& t);
//template <class Type> ostream& operator <<(ostream& os, const _Tuple2<Type>* t);

template <class Type> class VECMATH_EXPORT _Tuple2 {
public:
    Type x, y;

    _Tuple2<Type>() {}

    explicit _Tuple2<Type>(Type x, Type y = 0) : x(x), y(y) {
        DEBUGTUPLE2(std::cout << "_Tuple2 explicit constructor x,y " << *this << endl);
    }

    _Tuple2<Type>(const _Tuple2<byte>& t) {
        set(t);
        DEBUGTUPLE2(std::cout << "_Tuple2 constructor &byte " << *this << endl);
    }

    _Tuple2<Type>(const _Tuple2<double>& t) {
        set(t);
        DEBUGTUPLE2(std::cout << "_Tuple2 constructor &double " << *this << endl);
    }

    _Tuple2<Type>(const _Tuple2<float>& t) {
        set(t);
        DEBUGTUPLE2(std::cout << "_Tuple2 constructor &float " << *this << endl);
    }

    _Tuple2<Type>(const Type t[2]) {
        set(t);
        DEBUGTUPLE2(cout << "_Tuple2 constructor t[2] " << *this << endl);
    }

    ~_Tuple2<Type>() {
        DEBUGTUPLE2(cout << "_Tuple2 destructor " << *this << endl);
    }

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

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

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

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

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

    void clampMin(Type min) {
        DEBUGTUPLE2(cout << "_Tuple2 clampMin(" << min << ") = " << *this << endl);
        clampMin(min, *this);
    }

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

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

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

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

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

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

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

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

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

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

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

    void negate(const _Tuple2<Type> &t) {
        set(-t.x, -t.y);
    }

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

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

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

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

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

    void set(Type xx = 0, Type yy = 0) {
        x = xx;
        y = yy;
    }

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

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

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

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

    void sub(const _Tuple2<Type>& t) {
        sub(*this, t);
    }

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

#if 0   
    String &toString(String &s);
#endif
    //friend ostream& operator <<(ostream& os, const _Tuple2<Type>& t);

// non Java3D extensions

    // assignment

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

    // math operators

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

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

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

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

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

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

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

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

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

    bool operator !=(const _Tuple2<Type>& t) const {
        DEBUGTUPLE2(cout << "_Tuple2 operator!= _Tuple2 " << *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 _Tuple2<Type> & );
//    friend ostream & operator << <>( ostream &, const _Tuple2<Type> * );
};

#endif

---