_Tuple2.cc

Go to the documentation of this file.

#include <vecmath/_Tuple2.h>

template <class Type>
void _Tuple2<Type>::clamp(Type min, Type max, const _Tuple2<Type>& t)
{
    DEBUGTUPLE2(cout << "_Tuple2 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;

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

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

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

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

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

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

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

String& _Tuple2<int>::toString(String &s)
{
    char a[200];
    sprintf(a, "x: %d   y: %d", x, y);
    //s += a;
    return s;
}
#endif
template <class Type> std::ostream& operator <<(std::ostream& os, const _Tuple2<Type>& t)
{
    return os << "(" << t.x << ", " << t.y << ")";
}

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

template <class Type> _Tuple2<Type> operator *(Type c, const _Tuple2<Type>& t)
{
    DEBUGTUPLE2(std::cout << "_Tuple2 operator* Type _Tuple2 " << c << " * " << t << std::endl);
    return _Tuple2<Type>(c * t.x, c * t.y);
}

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

template _Tuple2<byte> operator *(byte c, const _Tuple2<byte>&);
template _Tuple2<double> operator *(double c, const _Tuple2<double>&);
template _Tuple2<float> operator *(float c, const _Tuple2<float>&);
template _Tuple2<int> operator *(int c, const _Tuple2<int>&);

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

---