src/TexCoordinate.h

Go to the documentation of this file.

#ifndef TEXCOORDINATE_H
#define TEXCOORDINATE_H

#include <iostream>
#include <cmath>
#include <cassert>

#include "defines.h"


class TexCoordinate
{
    // our friends
    friend TexCoordinate    min(const TexCoordinate a, const TexCoordinate b);
    friend TexCoordinate    max(const TexCoordinate a, const TexCoordinate b);
    friend TexCoordinate    operator*(const TexCoordinate & w, float f);
    friend TexCoordinate    operator*(float f, const TexCoordinate & w);
    friend TexCoordinate    operator/(const TexCoordinate & w, float f);
    friend std::ostream & operator<<(std::ostream & o, const TexCoordinate & w);

public:
    TexCoordinate()
    {
        mValues[0] = mValues[1] = 0.0f;
    }

    TexCoordinate(float x, float y)
    {
        mValues[0] = x;
        mValues[1] = y;
    }

    TexCoordinate(float f)
    {
        mValues[0] = f;
        mValues[1] = f;
    }

    inline void setX(float newx)
    {
    mValues[0] = newx;
    }

    inline float x() const
    {
        return mValues[0];
    }

    inline void setY(float newy)
    {
    mValues[1] = newy;
    }

    inline float y() const
    {
        return mValues[1];
    }

    inline float operator[](int i) const
    {
        return mValues[i];
    }

    inline TexCoordinate & operator=(const TexCoordinate & b)
    {
        mValues[0] = b.mValues[0];
        mValues[1] = b.mValues[1];
        return *this;
    }

    inline int maxDim() const
    {
        return (mValues[0] > mValues[1]) ? 0 : 1;
    }

    inline void setMin(TexCoordinate & other)
    {
        mValues[0] = std::min(mValues[0], other.mValues[0]);
        mValues[1] = std::min(mValues[1], other.mValues[1]);
    }

    inline void setMax(TexCoordinate & other)
    {
        mValues[0] = std::max(mValues[0], other.mValues[0]);
        mValues[1] = std::max(mValues[1], other.mValues[1]);
    }

    inline float dot(const TexCoordinate & b) const
    {
        return mValues[0]*b.mValues[0] + mValues[1]*b.mValues[1];
    }


    inline TexCoordinate fabs() const
    {
        return TexCoordinate(::fabs(mValues[0]), ::fabs(mValues[1]));
    }

    inline float length() const
    {
        return sqrtf(this->dot(*this));
    }

    inline TexCoordinate normal() const
    {
        assert(length() > EPSILON);     // avoid division by zero
        return *this * (1.0f / length());
    }

    inline void normalize()
    {
        assert(length() > EPSILON);     // avoid division by zero
        *this *= 1.0f / length();
    }

    inline TexCoordinate operator-() const
    {
        return TexCoordinate(-mValues[0], -mValues[1]);
    }

    inline void operator*=(float f)
    {
        mValues[0] *= f;
        mValues[1] *= f;
    }

    inline void scale(const TexCoordinate & w)
    {
        mValues[0] *= w.mValues[0];
        mValues[1] *= w.mValues[1];
    }

    inline TexCoordinate scaled(const TexCoordinate & w) const
    {
    return TexCoordinate( mValues[0] * w.mValues[0],
                  mValues[1] * w.mValues[1] );
    }

    inline void operator/=(float f)
    {
        (*this) *= (1.0f/f);
    }

    inline TexCoordinate operator+(const TexCoordinate & b) const
    {
        return TexCoordinate(mValues[0]+b.mValues[0], mValues[1]+b.mValues[1]);
    }

    inline TexCoordinate & operator+=(const TexCoordinate & b)
    {
        mValues[0] += b.mValues[0];
        mValues[1] += b.mValues[1];
        return *this;
    }

    inline TexCoordinate operator-(const TexCoordinate & b) const
    {
        return TexCoordinate(mValues[0]-b.mValues[0], mValues[1]-b.mValues[1]);
    }

    inline TexCoordinate & operator-=(const TexCoordinate & b)
    {
        mValues[0] -= b.mValues[0];
        mValues[1] -= b.mValues[1];
        return *this;
    }

    inline TexCoordinate reciprocal() const
    {
    return TexCoordinate( 1.0f/mValues[0], 1.0f/mValues[1] );
    }

private:
    float mValues[2];
};

inline TexCoordinate min(const TexCoordinate a, const TexCoordinate b)
{
    return TexCoordinate( std::min(a.mValues[0], b.mValues[0]),
              std::min(a.mValues[1], b.mValues[1]) );
}

inline TexCoordinate max(const TexCoordinate a, const TexCoordinate b)
{
    return TexCoordinate( std::max(a.mValues[0], b.mValues[0]),
              std::max(a.mValues[1], b.mValues[1]) );
}

inline TexCoordinate operator*(const TexCoordinate & w, float f)
{
    return TexCoordinate(f*w.mValues[0], f*w.mValues[1]);
}

inline TexCoordinate operator*(float f, const TexCoordinate & w)
{
    return TexCoordinate(f*w.mValues[0], f*w.mValues[1]);
}

inline TexCoordinate operator/(const TexCoordinate & w, float f)
{
    return w*(1.0f/f);
}

inline std::ostream & operator<<(std::ostream & o, const TexCoordinate & w)
{
    o << "(" << w.mValues[0] << ", " << w.mValues[1] << ")";
    return o;
}


#endif

---