src/Vec3f.h

Go to the documentation of this file.

#ifndef VEC3F_H
#define VEC3F_H


#include <iosfwd>
#include <cmath>
#include <algorithm>
#include <cassert>

#include "defines.h"


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

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

    Vec3f(float x, float y, float z)
    {
        mValues[0] = x;
        mValues[1] = y;
        mValues[2] = z;
    }

    Vec3f(float f)
    {
        mValues[0] = f;
        mValues[1] = f;
        mValues[2] = 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 void z(float newz)
    {
        mValues[2] = newz;
    }

    inline float z() const
    {
        return mValues[2];
    }

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

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

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

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

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

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

    inline Vec3f cross(const Vec3f & b) const
    {
        return Vec3f(   mValues[1]*b.mValues[2] - mValues[2]*b.mValues[1],
                        mValues[2]*b.mValues[0] - mValues[0]*b.mValues[2],
                        mValues[0]*b.mValues[1] - mValues[1]*b.mValues[0]);
    }

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

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

    inline Vec3f 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 Vec3f operator-() const
    {
        return Vec3f(-mValues[0], -mValues[1], -mValues[2]);
    }

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

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

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

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

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

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

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

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

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

    bool operator==(const Vec3f & v) const
    {
        return (this == &v)
                || (::fabs(mValues[0] - v.mValues[0]) <= EPSILON
                    && ::fabs(mValues[1] - v.mValues[1]) <= EPSILON
                    && ::fabs(mValues[2] - v.mValues[2]) <= EPSILON);
    }

    bool operator!=(const Vec3f & v) const
    {
        return !(*this == v);
    }

private:
    float mValues[3];
};


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

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

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

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

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


std::ostream & operator<<(std::ostream & o, const Vec3f & w);


std::istream & operator>>(std::istream & i, Vec3f & w);


#endif

---