vec2ll.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_Vec2L_H
#define Navigation_Vec2L_H


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


namespace Kaim
{


class Vec2LL
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

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

    Vec2LL(KyInt64 _x, KyInt64 _y) : x(_x), y(_y) {}

    explicit Vec2LL(KyInt64* coords) { Set(coords); }

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

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


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

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

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

    KY_INLINE bool operator==(const Vec2LL& v) const { return x == v.x && y == v.y; }

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

    KY_INLINE bool operator<(const Vec2LL& v) const
    {
        if (x < v.x) return true;
        if (x > v.x) return false;
        return (y < v.y);
    }

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

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

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

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


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

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

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

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

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

    KY_INLINE void SetAdditionResult(const Vec2LL& v1, const Vec2LL& v2) { x = v1.x + v2.x; y = v1.y + v2.y; }


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

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


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

    KyInt64 x; 
    KyInt64 y; 
};

inline Vec2LL operator * (KyInt64 lhs, const Vec2LL& rhs) { return rhs * lhs; }

KY_INLINE KyInt64 DotProduct(const Vec2LL& v1, const Vec2LL& v2) { return v1 * v2; }

KY_INLINE KyInt64 CrossProduct(const Vec2LL& v1, const Vec2LL& v2) { return v1.CrossProd(v2); }


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

} // namespace Kaim



#endif