vec2i.h

Go to the documentation of this file.

/*
* Copyright 2015 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.
*/


// primary contact: GUAL - secondary contact: NOBODY
#ifndef Navigation_Vec2i_H
#define Navigation_Vec2i_H


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

namespace Kaim
{


class Vec2i
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

public:
    // ---------------------------------- Creation & Initialization ----------------------------------

    Vec2i() : x(0), y(0) {}

    Vec2i(KyInt32 _x, KyInt32 _y) : x(_x), y(_y) {}

    explicit Vec2i(KyInt32* coords) { Set(coords); }

    KY_INLINE void Set(KyInt32 _x, KyInt32 _y) { x = _x; y = _y; }

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


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

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

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

    KY_INLINE bool operator==(const Vec2i& v) const { return ((x ^ v.x) | (y ^ v.y)) == 0/*x == v.x && y == v.y*/; }

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

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

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

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

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

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

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

    KY_INLINE KyInt32 operator*(const Vec2i& v) const { return x * v.x + y * v.y; } // DOT PROD

    KY_INLINE KyInt32 operator^(const Vec2i& v) const { return CrossProd(v); } // CROSS PROD 2D aka PERP PROD

    // -------------------------- Main interface --------------------------------

    KY_INLINE KyInt32 CrossProd(const Vec2i& v) const { return x * v.y - y * v.x; } // CROSS PROD 2D aka PERP PROD

    KY_INLINE KyInt32 Orient2d(const Vec2i& A, const Vec2i& B) const { return (A.x - x) * (B.y - y) - (B.x - x) * (A.y - y); } // > 0 if (MA,MB) is CCW

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

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

    KY_INLINE bool IsOnLeftSide(const Vec2i& A, const Vec2i& B) const { return Orient2d(A, B) >= 0; }

    KY_INLINE bool IsStrictlyOnLeftSide(const Vec2i& A, const Vec2i& B) const { return Orient2d(A, B) > 0; }

    KY_INLINE KyInt32 GetSquareLength() const { return x * x + y * y; }


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

    KY_INLINE Vec2i NeighborEast() const { return Vec2i(x + 1, y    ); }

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

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

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

    KY_INLINE void NeighborSouth(Vec2i& neighbor) const { neighbor.Set(x    , y - 1); }

    KY_INLINE Vec2i Neighbor(CardinalDir dir) const
    {
        Vec2i returnCellPos;
        Neighbor(dir, returnCellPos);
        return returnCellPos;
    }

    KY_INLINE void Neighbor(CardinalDir dir, Vec2i& neighbor) const
    {
        static const Vec2i s_cardinalDirToNeighbor[4] =
        {
            /*CardinalDir_EAST*/Vec2i(1, 0),
            /*CardinalDir_NORTH*/Vec2i(0, 1),
            /*CardinalDir_WEST*/Vec2i(-1, 0),
            /*CardinalDir_SOUTh*/Vec2i(0, -1)
        };

        neighbor.x = x + s_cardinalDirToNeighbor[dir].x;
        neighbor.y = y + s_cardinalDirToNeighbor[dir].y;
    }

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


    // -------------------------- Triangle Inclusion Checkers --------------------------------

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

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

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

    // -------------------------- Static methods --------------------------------

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


    // ---------------------------------- Public Data Members ----------------------------------

    KyInt32 x; 
    KyInt32 y; 
};

inline Vec2i operator * (KyInt32 lhs, const Vec2i& rhs) { return rhs * lhs; }

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

KY_INLINE KyInt32 SquareDistance(const Vec2i& v1, const Vec2i& v2)
{
    const KyInt32 dx = v2.x - v1.x;
    const KyInt32 dy = v2.y - v1.y;
    return dx * dx + dy * dy;
}

KY_INLINE bool Vec2i::IsInsideTriangle(const Vec2i& A, const Vec2i& B, const Vec2i& C) const
{
    if (A.Orient2d(B, C) == 0) // flat triangle
    {
        if (A.x == B.x) // vertical
        {
            // not vertical
            if (y < A.y && y < B.y && y < C.y) 
                return false; // M is below of ABC
            if (y > A.y && y > B.y && y > C.y)
                return false; // M is above of ABC
            return true; // M is on ABC
        }
        else // not vertical
        {
            if (x < A.x && x < B.x && x < C.x) 
                return false; // M is "left" of ABC
            if (x > A.x && x > B.x && x > C.x)
                return false; // M is "right" of ABC
            return true; // M is on ABC
        }
    }

    return IsInsideNotColinearTriangle(A, B, C);
}


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


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

KY_INLINE KyInt32 DotProduct(const Vec2i& v1, const Vec2i& v2) { return v1 * v2; }

KY_INLINE KyInt32 CrossProduct(const Vec2i& v1, const Vec2i& v2) { return v1.CrossProd(v2); }


template <typename T> KY_INLINE T CrossProductT(const Vec2i& v1, const Vec2i& v2) { return (T)(v1.x) * (T)(v2.y) - (T)(v1.y) * (T)(v2.x); }
template <typename T> KY_INLINE T DotProductT(const Vec2i& v1, const Vec2i& v2) { return (T)(v1.x) * (T)(v2.x) + (T)(v1.y) * (T)(v2.y); }

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

} // namespace Kaim



#endif