vec2i.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/base/memory.h"
#include "gwnavruntime/base/endianness.h"
#include "gwnavruntime/math/cardinaldir.h"
#include "gwnavruntime/math/fastmath.h"

namespace Kaim
{

class Vec2i
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

public:
    // ------------------------------ Functions -----------------------------

    Vec2i() : x(0), y(0) {}                            
    Vec2i(KyInt32 _x, KyInt32 _y) : x(_x), y(_y) {}    
    explicit Vec2i(KyInt32* coords) { Set(coords); }   

    void Set(KyInt32 _x, KyInt32 _y) { x = _x; y = _y; }        
    void Set(KyInt32* coords) { x = coords[0]; y = coords[1]; } 

    void Clear() { x = 0; y = 0; } 

    // ------------------------------ Operators -----------------------------

    KyInt32& operator[](KyInt32 idx) { return (&x)[idx]; }
    KyInt32 operator[](KyInt32 idx) const { return (&x)[idx]; }

    bool operator==(const Vec2i& v) const { return x == v.x && y == v.y; }
    bool operator!=(const Vec2i& v) const { return !operator==(v); }

    bool operator<(const Vec2i& v)  const { return (x != v.x) ? x < v.x : y < v.y;  }  
    bool operator<=(const Vec2i& v) const { return (x != v.x) ? x < v.x : y <= v.y; }
    bool operator>(const Vec2i& v)  const { return (x != v.x) ? x > v.x : y > v.y;  }
    bool operator>=(const Vec2i& v) const { return (x != v.x) ? x < v.x : y >= v.y; }

    Vec2i& operator*=(KyInt32 s)      { x *= s;   y *= s;   return *this; }
    Vec2i& operator/=(KyInt32 d)      { x /= d;   y /= d;   return *this; }
    Vec2i& operator+=(const Vec2i& v) { x += v.x; y += v.y; return *this; }
    Vec2i& operator-=(const Vec2i& v) { x -= v.x; y -= v.y; return *this; }

    Vec2i operator*(KyInt32 s)      const { return Vec2i(x * s  , y * s  ); }
    Vec2i operator/(KyInt32 d)      const { return Vec2i(x / d  , y / d  ); }
    Vec2i operator+(const Vec2i& v) const { return Vec2i(x + v.x, y + v.y); }
    Vec2i operator-(const Vec2i& v) const { return Vec2i(x - v.x, y - v.y); }
    Vec2i operator-()               const { return Vec2i(-x     , -y     ); }

    // ------------------------------ SquareLength -----------------------------

    KyInt64 SqLength()        const { return KyInt64(x) * KyInt64(x) + KyInt64(y) * KyInt64(y); }
    KyInt64 SqLength_15bits() const { return x * x + y * y; }
    bool IsZero() const { return x == 0 && y == 0; }

    // -------------------------- Offset --------------------------------

    Vec2i OffsetX(KyInt32 dx) const { return Vec2i(x + dx, y); } 
    Vec2i OffsetY(KyInt32 dy) const { return Vec2i(x, y + dy); } 
    Vec2i Offset(KyInt32 dx, KyInt32 dy) const { return Vec2i(x + dx, y + dy); } 

    // ------------------------------ Rotation -----------------------------

    Vec2i PerpCCW() const { return Vec2i(y, -x); }
    Vec2i PerpCW() const { return Vec2i(-y, x); }

    // ------------------------------ Side -----------------------------

    KyInt64 Orient2d(const Vec2i& A, const Vec2i& B) const { return KyInt64(A.x - x) * KyInt64(B.y - y) - KyInt64(B.x - x) * KyInt64(A.y - y); } // > 0 if (MA,MB) is CCW
    bool IsOnLeftSide(const Vec2i& A, const Vec2i& B) const { return Orient2d(A, B) >= 0; }
    bool IsStrictlyOnLeftSide(const Vec2i& A, const Vec2i& B) const { return Orient2d(A, B) > 0; }

    // ------------------------------ IsInside -----------------------------

    bool IsInsideTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const;
    bool IsInsideNotColinearTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const;
    bool IsStrictlyInsideTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const;

    // ------------------------------ Zero, Unit -----------------------------

    static Vec2i Zero()  { return Vec2i(0, 0); }
    static Vec2i UnitX() { return Vec2i(1, 0); }
    static Vec2i UnitY() { return Vec2i(0, 1); }

    // ------------------------------ Neighbors -----------------------------

    Vec2i NeighborEast()  const { return Vec2i(x + 1, y    ); }
    Vec2i NeighborWest()  const { return Vec2i(x - 1, y    ); }
    Vec2i NeighborNorth() const { return Vec2i(x    , y + 1); }
    Vec2i NeighborSouth() const { return Vec2i(x    , y - 1); }

    void NeighborEast(Vec2i& neighbor)  const { neighbor.Set(x + 1, y    ); }
    void NeighborWest(Vec2i& neighbor)  const { neighbor.Set(x - 1, y    ); }
    void NeighborNorth(Vec2i& neighbor) const { neighbor.Set(x    , y + 1); }
    void NeighborSouth(Vec2i& neighbor) const { neighbor.Set(x    , y - 1); }

    Vec2i Neighbor(CardinalDir dir) const
    {
        const KyInt8 dx[4] = { 1,  0, -1,  0 };
        const KyInt8 dy[4] = { 0,  1,  0, -1 };
        return Vec2i(x + dx[dir], y + dy[dir]);
    }

    void Neighbor(CardinalDir dir, Vec2i& neighbor) const
    {
        const KyInt8 dx[4] = {1, 0, -1, 0};
        const KyInt8 dy[4] = {0, 1, 0, -1};
        neighbor.Set(x + dx[dir], y + dy[dir]);
    }

    Vec2i NeighborNorthEast() const { return Vec2i(x + 1, y + 1); }
    Vec2i NeighborNorthWest() const { return Vec2i(x - 1, y + 1); }
    Vec2i NeighborSouthEast() const { return Vec2i(x + 1, y - 1); }
    Vec2i NeighborSouthWest() const { return Vec2i(x - 1, y - 1); }

    // ------------------------------ Data -----------------------------

    KyInt32 x;
    KyInt32 y;
};

inline void SwapEndianness(Kaim::Endianness::Target e, Vec2i& self)
{
    SwapEndianness(e, self.x);
    SwapEndianness(e, self.y);
}

inline Vec2i Seg(const Vec2i& A, const Vec2i& B) { return B - A; }

inline KyInt64 SquareDistance(const Vec2i& A, const Vec2i& B) { return Seg(A, B).SqLength(); }

inline KyInt32 DotProduct_15bits(const Vec2i& v1, const Vec2i& v2)   { return v1.x * v2.x + v1.y * v2.y; }
inline KyInt32 CrossProduct_15bits(const Vec2i& v1, const Vec2i& v2) { return v1.x * v2.y - v1.y * v2.x; }

inline KyInt64 DotProduct(const Vec2i& v1, const Vec2i& v2)   { return KyInt64(v1.x) * KyInt64(v2.x) + KyInt64(v1.y) * KyInt64(v2.y); }
inline KyInt64 CrossProduct(const Vec2i& v1, const Vec2i& v2) { return KyInt64(v1.x) * KyInt64(v2.y) - KyInt64(v1.y) * KyInt64(v2.x); }

inline bool AreAligned(const Vec2i& A, const Vec2i& B, const Vec2i& C) { return CrossProduct(B - A, C - A) == 0; }

inline KyInt32 Side(const Vec2i& P, const Vec2i& A, const Vec2i& B) { return (KyInt32)Lsign(CrossProduct(B - A, P - A)); } // ABxAP

inline bool Vec2i::IsInsideTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const
{
    if (AreAligned(A, B, C) == 0) // flat triangle
    {
        if (A.x == B.x && A.x == C.x) // vertical
        {
            if (y < A.y && y < B.y && y < C.y) { return false; } // M.y < ABC.y
            if (y > A.y && y > B.y && y > C.y) { return false; } // M.y > ABC.y
            return true; // M is on ABC
        }
        else // not vertical
        {
            if (x < A.x && x < B.x && x < C.x) { return false; } // M.x < ABC.x
            if (x > A.x && x > B.x && x > C.x) { return false; } // M.x > ABC.x
            return true; // M is on ABC
        }
    }

    return IsInsideNotColinearTriangle(A, B, C);
}


inline bool Vec2i::IsInsideNotColinearTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const
{
    return IsOnLeftSide(A, B) && IsOnLeftSide(B, C) && IsOnLeftSide(C, A);
}


inline bool Vec2i::IsStrictlyInsideTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const
{
    return IsStrictlyOnLeftSide(A, B) && IsStrictlyOnLeftSide(B, C) && IsStrictlyOnLeftSide(C, A);
}

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Kaim::Vec2i& v)
{
    os << "{" << v.x << "," << v.y << "}";
    return os;
}

}