Vector3.h

Go to the documentation of this file.

 
#pragma once
 
 
 
 
 
template <typename T>
// tolua_begin
class Vector3
{
 
    TOLUA_TEMPLATE_BIND((T, int, float, double))
 
public:
 
    T x, y, z;
 
 
    constexpr Vector3(void) : x(0), y(0), z(0) {}
    constexpr Vector3(T a_x, T a_y, T a_z) : x(a_x), y(a_y), z(a_z) {}
 
 
    #ifdef TOLUA_EXPOSITION  // Hardcoded copy constructors (tolua++ does not support function templates .. yet)
        Vector3(const Vector3<float>  & a_Rhs);
        Vector3(const Vector3<double> & a_Rhs);
        Vector3(const Vector3<int>    & a_Rhs);
    #endif
 
 
    // tolua_end
    // Conversion constructors where U is not the same as T leaving the copy-constructor implicitly generated
    template <typename U, typename = typename std::enable_if<!std::is_same<U, T>::value>::type>
    constexpr Vector3(const Vector3<U> & a_Rhs):
            x(static_cast<T>(a_Rhs.x)),
            y(static_cast<T>(a_Rhs.y)),
            z(static_cast<T>(a_Rhs.z))
    {
    }
    // tolua_begin
 
    inline void Set(T a_x, T a_y, T a_z)
    {
        x = a_x;
        y = a_y;
        z = a_z;
    }
 
    inline void Normalize(void)
    {
        double Len = 1.0 / Length();
 
        x = static_cast<T>(x * Len);
        y = static_cast<T>(y * Len);
        z = static_cast<T>(z * Len);
    }
 
    inline Vector3<T> NormalizeCopy(void) const
    {
        double Len = 1.0 / Length();
 
        return Vector3<T>(
            static_cast<T>(x * Len),
            static_cast<T>(y * Len),
            static_cast<T>(z * Len)
        );
    }
 
    // tolua_end
 
    inline void NormalizeCopy(Vector3<T> & a_Rhs) const
    {
        double Len = 1.0 / Length();
 
        a_Rhs.Set(
            static_cast<T>(x * Len),
            static_cast<T>(y * Len),
            static_cast<T>(z * Len)
        );
    }
 
    // tolua_begin
 
    inline bool HasNonZeroLength(void) const
    {
        #ifdef __clang__
            #pragma clang diagnostic push
            #pragma clang diagnostic ignored "-Wfloat-equal"
        #endif
 
        return ((x != 0) || (y != 0) || (z != 0));
 
        #ifdef __clang__
            #pragma clang diagnostic pop
        #endif
    }
 
    inline double Length(void) const
    {
        return sqrt(static_cast<double>(x * x + y * y + z * z));
    }
 
    inline double SqrLength(void) const
    {
        return x * x + y * y + z * z;
    }
 
    inline T Dot(const Vector3<T> & a_Rhs) const
    {
        return x * a_Rhs.x + y * a_Rhs.y + z * a_Rhs.z;
    }
 
    inline void Abs()
    {
        x = std::abs(x);
        y = std::abs(y);
        z = std::abs(z);
    }
 
    inline void Clamp(T a_Min, T a_Max)
    {
        x = ::Clamp(x, a_Min, a_Max);
        y = ::Clamp(y, a_Min, a_Max);
        z = ::Clamp(z, a_Min, a_Max);
    }
 
    inline Vector3<T> Cross(const Vector3<T> & a_Rhs) const
    {
        return Vector3<T>(
            y * a_Rhs.z - z * a_Rhs.y,
            z * a_Rhs.x - x * a_Rhs.z,
            x * a_Rhs.y - y * a_Rhs.x
        );
    }
 
    inline bool Equals(const Vector3<T> & a_Rhs) const
    {
        // Perform a strict comparison of the contents - we want to know whether this object is exactly equal
        // To perform EPS-based comparison, use the EqualsEps() function
 
        #ifdef __clang__
            #pragma clang diagnostic push
            #pragma clang diagnostic ignored "-Wfloat-equal"
        #endif
 
        return !((x != a_Rhs.x) || (y != a_Rhs.y) || (z != a_Rhs.z));
 
        #ifdef __clang__
            #pragma clang diagnostic pop
        #endif
    }
 
    inline bool EqualsEps(const Vector3<T> & a_Rhs, T a_Eps) const
    {
        return (std::abs(x - a_Rhs.x) < a_Eps) && (std::abs(y - a_Rhs.y) < a_Eps) && (std::abs(z - a_Rhs.z) < a_Eps);
    }
 
    inline void Move(T a_X, T a_Y, T a_Z)
    {
        x += a_X;
        y += a_Y;
        z += a_Z;
    }
 
    inline void Move(const Vector3<T> & a_Diff)
    {
        x += a_Diff.x;
        y += a_Diff.y;
        z += a_Diff.z;
    }
 
    inline Vector3<int> Floor(void) const
    {
        return Vector3<int>(
            FloorC(x),
            FloorC(y),
            FloorC(z)
        );
    }
 
    inline Vector3<int> Ceil() const
    {
        return Vector3<int>(
            CeilC(x),
            CeilC(y),
            CeilC(z)
        );
    }
 
    // tolua_end
 
    inline bool operator != (const Vector3<T> & a_Rhs) const
    {
        return !Equals(a_Rhs);
    }
 
    inline bool operator == (const Vector3<T> & a_Rhs) const
    {
        return Equals(a_Rhs);
    }
 
    inline bool operator > (const Vector3<T> & a_Rhs) const
    {
        return (SqrLength() > a_Rhs.SqrLength());
    }
 
    inline bool operator < (const Vector3<T> & a_Rhs) const
    {
        return (SqrLength() < a_Rhs.SqrLength());
    }
 
    inline void operator += (const Vector3<T> & a_Rhs)
    {
        x += a_Rhs.x;
        y += a_Rhs.y;
        z += a_Rhs.z;
    }
 
    inline void operator -= (const Vector3<T> & a_Rhs)
    {
        x -= a_Rhs.x;
        y -= a_Rhs.y;
        z -= a_Rhs.z;
    }
 
    inline void operator *= (const Vector3<T> & a_Rhs)
    {
        x *= a_Rhs.x;
        y *= a_Rhs.y;
        z *= a_Rhs.z;
    }
 
    inline void operator *= (T a_v)
    {
        x *= a_v;
        y *= a_v;
        z *= a_v;
    }
 
    // tolua_begin
 
    inline Vector3<T> operator + (const Vector3<T>& a_Rhs) const
    {
        return Vector3<T>(
            x + a_Rhs.x,
            y + a_Rhs.y,
            z + a_Rhs.z
        );
    }
 
    inline Vector3<T> operator - (const Vector3<T>& a_Rhs) const
    {
        return Vector3<T>(
            x - a_Rhs.x,
            y - a_Rhs.y,
            z - a_Rhs.z
        );
    }
 
    inline Vector3<T> operator - (void) const
    {
        return Vector3<T>(-x, -y, -z);
    }
 
    inline Vector3<T> operator * (const Vector3<T>& a_Rhs) const
    {
        return Vector3<T>(
            x * a_Rhs.x,
            y * a_Rhs.y,
            z * a_Rhs.z
        );
    }
 
    inline Vector3<T> operator / (const Vector3<T> & a_Rhs)
    {
        return Vector3<T>(
            x / a_Rhs.x,
            y / a_Rhs.y,
            z / a_Rhs.z
        );
    }
 
    inline Vector3<T> operator * (T a_v) const
    {
        return Vector3<T>(
            x * a_v,
            y * a_v,
            z * a_v
        );
    }
 
    inline Vector3<T> operator / (T a_v) const
    {
        return Vector3<T>(
            x / a_v,
            y / a_v,
            z / a_v
        );
    }
 
    inline Vector3<T> addedX(T a_AddX) const
    {
        return Vector3<T>(x + a_AddX, y, z);
    }
 
    inline Vector3<T> addedY(T a_AddY) const
    {
        return Vector3<T>(x, y + a_AddY, z);
    }
 
    inline Vector3<T> addedZ(T a_AddZ) const
    {
        return Vector3<T>(x, y, z + a_AddZ);
    }
 
    inline Vector3<T> addedXZ(T a_AddX, T a_AddZ) const
    {
        return Vector3<T>(x + a_AddX, y, z + a_AddZ);
    }
 
    inline double LineCoeffToXYPlane(const Vector3<T> & a_OtherEnd, T a_Z) const
    {
        if (std::abs(z - a_OtherEnd.z) < EPS)
        {
            return NO_INTERSECTION;
        }
 
        return (a_Z - z) / (a_OtherEnd.z - z);
    }
 
    inline double LineCoeffToXZPlane(const Vector3<T> & a_OtherEnd, T a_Y) const
    {
        if (std::abs(y - a_OtherEnd.y) < EPS)
        {
            return NO_INTERSECTION;
        }
 
        return (a_Y - y) / (a_OtherEnd.y - y);
    }
 
    inline double LineCoeffToYZPlane(const Vector3<T> & a_OtherEnd, T a_X) const
    {
        if (std::abs(x - a_OtherEnd.x) < EPS)
        {
            return NO_INTERSECTION;
        }
 
        return (a_X - x) / (a_OtherEnd.x - x);
    }
 
    inline void TurnCW(void)
    {
        std::swap(x, z);
        x = -x;
    }
 
    inline void TurnCCW(void)
    {
        std::swap(x, z);
        z = -z;
    }
 
    static const double EPS;
 
    static const double NO_INTERSECTION;
};
// tolua_end
 
 
 
 
 
template <typename What>
class fmt::formatter<Vector3<What>> : public fmt::formatter<What>
{
    using Super = fmt::formatter<What>;
 
    template <typename FormatContext, size_t Len>
    void Write(FormatContext & a_Ctx, const char (& a_Str)[Len])
    {
        const auto Itr = std::copy_n(&a_Str[0], Len - 1, a_Ctx.out());
        a_Ctx.advance_to(Itr);
    }
 
    template <typename FormatContext>
    void Write(FormatContext & a_Ctx, const What & a_Arg)
    {
        const auto Itr = Super::format(a_Arg, a_Ctx);
        a_Ctx.advance_to(Itr);
    }
 
public:
 
    template <typename FormatContext>
    auto format(const Vector3<What> & a_Vec, FormatContext & a_Ctx)
    {
        Write(a_Ctx, "{");
        Write(a_Ctx, a_Vec.x);
        Write(a_Ctx, ", ");
        Write(a_Ctx, a_Vec.y);
        Write(a_Ctx, ", ");
        Write(a_Ctx, a_Vec.z);
        Write(a_Ctx, "}");
        return a_Ctx.out();
    }
};
 
 
 
 
 
template <> inline Vector3<int> Vector3<int>::Floor(void) const
{
    return *this;
}
 
 
 
 
 
template <typename What>
class VectorHasher
{
public:
    size_t operator()(const Vector3<What> & a_Vector) const
    {
        // Guaranteed to have non repeating hashes for any 128x128x128 area
        size_t Hash = static_cast<size_t>(a_Vector.y);
        Hash <<= 16;
        Hash ^= static_cast<size_t>(a_Vector.x);
        Hash ^= static_cast<size_t>(a_Vector.z) << 8;
        return Hash;
    }
};
 
 
 
 
 
template <typename T>
const double Vector3<T>::EPS = 0.000001;
 
template <typename T>
const double Vector3<T>::NO_INTERSECTION = 1e70;
 
 
 
 
 
// tolua_begin
typedef Vector3<double> Vector3d;
typedef Vector3<float>  Vector3f;
typedef Vector3<int>    Vector3i;
// tolua_end
 
 
 
 
 
typedef std::vector<Vector3i> cVector3iArray;