vec2ll.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 <math.h>

namespace Kaim
{

class Vec2LL
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    KyInt64 x;
    KyInt64 y;
};

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

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

}