_Tuple3.h

Go to the documentation of this file.

#ifndef __VECMATH_TUPLE3_HPP
#define __VECMATH_TUPLE3_HPP

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

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

#include <vecmath/String.h>

//#define DEBUGTUPLE3(d) d
#define DEBUGTUPLE3(d)


// general template for Tuple3
// (used by Tuple3f, Tuple3d, Vector3f, Vector3d, Point3d, Point3d)
//
// for standard functions see documentation for Java3D
//
// all standard overloaded operation are also support
//

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

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

    _Tuple3<Type>() {}

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

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

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

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

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

    _Tuple3<Type>(const Type t[3]) {
        set(t);
        DEBUGTUPLE3(cout << "_Tuple3 constructor v[3] " << *this << endl);
    }

    ~_Tuple3<Type>() {
        DEBUGTUPLE3(cout << "_Tuple3 destructor " << *this << endl);
    }

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

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

    static Type* add(Type t[3], const Type t1[3], const Type t2[3]) {
        t[0] = t1[0] + t2[0];
        t[1] = t1[1] + t2[1];
        t[2] = t1[2] + t2[2];
        return t;
    }

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

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

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

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

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

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

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

    bool epsilonEquals(const _Tuple3<Type> &t, Type epsilon) const {
        DEBUGTUPLE3(cout << "_Tuple3 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));
    }

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

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

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

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

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

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

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

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

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

    static void negate(Type t[3], Type t1[3]) {
        t[0] = -t1[0];
        t[1] = -t1[1];
        t[2] = -t1[2];
    }

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

    static Type normSquared(const Type t[3]) {
        fprintf(stderr,"norm: %f\n",(float)Math::sqr(t[0]) + Math::sqr(t[1]) + Math::sqr(t[2]));
        return Type(Math::sqr(t[0]) + Math::sqr(t[1]) + Math::sqr(t[2]));
    }

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

    // extension
    static Type norm(const Type t[3]) {
        return Type(sqrt(normSquared(t)));
    }

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

    static Type* scale(Type t[3], Type s) {
        t[0] *= s;
        t[1] *= s;
        t[2] *= s;

        return t;
    }

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

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

    void scaleAdd(Type s, const float t1[3], const float t2[3]) {
        x = Type(s * t1[0] + t2[0]);
        y = Type(s * t1[1] + t2[1]);
        z = Type(s * t1[2] + t2[2]);
    }

    static Type* scaleAdd(Type t[3], Type s, const Type t1[3], const Type t2[3]) {
        t[0] = s * t1[0] + t2[0];
        t[1] = s * t1[1] + t2[1];
        t[2] = s * t1[2] + t2[2];
        return t;
    }

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

    void set(Type t[3]) {
        x = t[0];
        y = t[1];
        z = t[2];
    }

    static Type* set(Type t[3], Type xx, Type yy, Type zz) {
        t[0] = xx;
        t[1] = yy;
        t[2] = zz;

        return t;
    }

    void set(const _Tuple3<byte>& 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<float>& 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 sub(const _Tuple3<Type>& t) {
        sub(*this, t);
    }

    static Type* sub(Type t[3], const Type t1[3]) {
        return sub(t, t, t1);
    }

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

    static Type* sub(Type t[3], const Type t1[3], const Type t2[3]) {
        t[0] = t1[0] - t2[0];
        t[1] = t1[1] - t2[1];
        t[2] = t1[2] - t2[2];

        return t;
    }

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

    //friend ostream& operator <<(ostream& os, const _Tuple3<Type>& t);

// non Java3D extensions

    // assignment

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

    // math operators

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

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

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

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

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

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

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

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

//      friend _Tuple3<Type> operator *(Type c, const _Tuple3<Type>& t) {
//      DEBUGTUPLE3(cout << "_Tuple3 operator* Type _Tuple3 " << c << " * " << t << endl);
//      return _Tuple3<Type>(c * t.x, c * t.y, c * t.z);
//      }

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

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

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

    operator const Type * () const {
        return &x;
    }
    // use predeclared template
    // <> suppress warning message
    //friend ostream & operator << <>( ostream &, const _Tuple3<Type> & );
    //friend ostream & operator << <>( ostream &, const _Tuple3<Type> * );
};

#endif

---