_Tuple3.cc

Go to the documentation of this file.

#include <vecmath/_Tuple3.h>

template <class Type>
void _Tuple3<Type>::clamp(Type min, Type max, const _Tuple3<Type>& t)
{
    DEBUGTUPLE3(std::cout << "_Tuple3 clamp( " << min << ", " << max
                << ", " << t << " )");
    if (t.x < min)
        x = min;
    else if (t.x > max)
        x = max;
    else
        x = t.x;

    if (t.y < min)
        y = min;
    else if (t.y > max)
        y = max;
    else
        y = t.y;

    if (t.z < min)
        z = min;
    else if (t.z > max)
        z = max;
    else
        z = t.z;

    DEBUGTUPLE3(std::cout << " = " << *this << std::endl);
}

template <class Type>
void _Tuple3<Type>::clampMax(Type max, const _Tuple3<Type>& t)
{
    DEBUGTUPLE3(cout << "_Tuple3 clampMax( " << max << ", " << t << " ) ");
    x = (t.x > max) ? max : t.x;
    y = (t.y > max) ? max : t.y;
    z = (t.z > max) ? max : t.z;
    DEBUGTUPLE3(std::cout << " = " << *this << std::endl);
}

template <class Type>
void _Tuple3<Type>::clampMin(Type min, const _Tuple3<Type>& t)
{
    DEBUGTUPLE3(std::cout << "_Tuple3 clampMin( " << min << ", " << t << " ) ");
    x = (t.x < min) ? min : t.x;
    y = (t.y < min) ? min : t.y;
    z = (t.z < min) ? min : t.z;
    DEBUGTUPLE3(std::cout << " = " << *this << std::endl);
}

template <class Type>
void _Tuple3<Type>::interpolate(_Tuple3<Type> &t1, const _Tuple3<Type> &t2, double alpha)
{
    x = Type((1.0 - alpha) * t1.x + alpha * t2.x);
    y = Type((1.0 - alpha) * t1.y + alpha * t2.y);
    z = Type((1.0 - alpha) * t1.z + alpha * t2.z);
}

#if 0   
String& _Tuple3<byte>::toString(String &s)
{
    char a[200];
    sprintf(a, "x: %d   y: %d   z: %d", x, y, z);
    //s += a;
    return s;
}

String& _Tuple3<double>::toString(String &s)
{
    char a[200];
    sprintf(a, "x: %f   y: %f   z: %f", x, y, z);
    //s += a;
    return s;
}

String& _Tuple3<float>::toString(String &s)
{
    char a[200];
    sprintf(a, "x: %f   y: %f   z: %f", x, y, z);
    //s += a;
    return s;
}

String& _Tuple3<int>::toString(String &s)
{
    char a[200];
    sprintf(a, "x: %d   y: %d   z: %d", x, y, z);
    //s += a;
    return s;
}
#endif


//  template <class Type> inline
//  _Tuple3<Type>& operator +(const _Tuple3<Type> &u, const _Tuple3<Type> &v) {
//      cout << "_Tuple3 operator + _Tuple3  & _Tuple3" << endl;
//      //return _Tuple3(u.x + v.x, u.y + v.y, u.z + v.z);
//      set(u.x + v.x, u.y + v.y, u.z + v.z);
//      return *this;
//  }

// works - but might have problems

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

template <class Type> std::ostream& operator <<(std::ostream& os, const _Tuple3<Type>& t)
{
    return os << "(" << t.x << ", " << t.y << ", " << t.z << ")";
}

template <class Type> std::ostream& operator <<(std::ostream& os, const _Tuple3<Type>* t)
{
    return os << *t;
}

template class _Tuple3<byte>;
template class _Tuple3<double>;
template class _Tuple3<float>;
template class _Tuple3<int>;

template std::ostream& operator <<(std::ostream&, const _Tuple3<byte>&);
template std::ostream& operator <<(std::ostream&, const _Tuple3<byte>*);
template std::ostream& operator <<(std::ostream&, const _Tuple3<double>&);
template std::ostream& operator <<(std::ostream&, const _Tuple3<double>*);
template std::ostream& operator <<(std::ostream&, const _Tuple3<float>&);
template std::ostream& operator <<(std::ostream&, const _Tuple3<float>*);
template std::ostream& operator <<(std::ostream&, const _Tuple3<int>&);
template std::ostream& operator <<(std::ostream&, const _Tuple3<int>*);

---