|| || || || || || || ||

---

Vec3Int32.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_Vec3Int32_h
#define Impala_Core_Array_Element_Vec3Int32_h

#include <iostream>
#include "Util/Math.h"
#include "Basis/NativeTypes.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Element
{


class Vec3Int32 {
public:

    Vec3Int32()
    {
    }

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

    Vec3Int32(Int32 i)
    {
        mValues[0] = i;
        mValues[1] = i;
        mValues[2] = i;
    }

    Vec3Int32(const Vec3Int32& v)
    {
        mValues[0] = v.mValues[0];
        mValues[1] = v.mValues[1];
        mValues[2] = v.mValues[2];
    }

    /*
    Vec3Int32& operator=(const Vec3Int32& v)
    {
        mValues[0] = v.mValues[0];
        mValues[1] = v.mValues[1];
        mValues[2] = v.mValues[2];
        return *this;
    }
    */
    Int32
    X() const
    {
        return mValues[0];
    }
    
    Int32
    Y() const
    {
        return mValues[1];
    }
    
    Int32
    Z() const
    {
        return mValues[2];
    }

    Int32
    getValue(int dimension) const
    {
        return mValues[dimension - 1];
    }

    int
    operator==(const Vec3Int32& v) const
    {
        return (mValues[0] == v.mValues[0]) && (mValues[1] == v.mValues[1]) &&
               (mValues[2] == v.mValues[2]);
    }

    int
    operator<(const Vec3Int32& v) const
    {
        return (std::abs(mValues[0]) + std::abs(mValues[1]) + std::abs(mValues[2])) < 
               (std::abs(v.mValues[0]) + std::abs(v.mValues[1]) + std::abs(v.mValues[2]));
    }

    int
    operator<=(const Vec3Int32& v) const
    {
        return (std::abs(mValues[0]) + std::abs(mValues[1]) + std::abs(mValues[2])) <=
            (std::abs(v.mValues[0]) + std::abs(v.mValues[1]) + std::abs(v.mValues[2]));
    }

    int
    operator> (const Vec3Int32& v) const
    {
        return (std::abs(mValues[0]) + std::abs(mValues[1]) + std::abs(mValues[2])) >
            (std::abs(v.mValues[0]) + std::abs(v.mValues[1]) + std::abs(v.mValues[2]));
    }

    int
    operator>=(const Vec3Int32& v) const
    {
        return (std::abs(mValues[0]) + std::abs(mValues[1]) + std::abs(mValues[2])) >=
            (std::abs(v.mValues[0]) + std::abs(v.mValues[1]) + std::abs(v.mValues[2]));
    }

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


private:
    Int32 mValues[3];
};

inline std::ostream&
operator<<(std::ostream& os, const Vec3Int32& v)
{
    return os << "(" << v.X() << "," << v.Y() << "," << v.Z() << ")";
}

inline Vec3Int32
operator+(const Vec3Int32& v1, const Vec3Int32& v2)
{
    return Vec3Int32(v1.X() + v2.X(), v1.Y() + v2.Y(), v1.Z() + v2.Z());
}

inline Vec3Int32
operator-(const Vec3Int32& v1, const Vec3Int32& v2)
{
    return Vec3Int32(v1.X() - v2.X(), v1.Y() - v2.Y(), v1.Z() - v2.Z());
}

inline Vec3Int32
operator*(const Vec3Int32& v1, const Vec3Int32& v2)
{
    return Vec3Int32(v1.X() * v2.X(), v1.Y() * v2.Y(), v1.Z() * v2.Z());
}

inline Vec3Int32
operator/(const Vec3Int32& v1, const Vec3Int32& v2)
{
    return Vec3Int32(v1.X() / v2.X(), v1.Y() / v2.Y(), v1.Z() / v2.Z());
}

} // namespace Element
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---