vec2f.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/fastmath.h"

namespace Kaim
{

class Vec2f
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

    Vec2f() : x(0.0f), y(0.0f) {} 
    Vec2f(KyFloat32 _x, KyFloat32 _y) : x(_x), y(_y) {}
    explicit Vec2f(KyFloat32* coords) { Set(coords); } 

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

    void Clear() { x = 0.0f; y = 0.0f; } 

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

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

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

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

    Vec2f& operator*=(KyFloat32 s)    { x *= s; y *= s; return *this; }
    Vec2f& operator/=(KyFloat32 d)    { return operator*=(1.0f / d); }
    Vec2f& operator+=(const Vec2f& v) { x += v.x; y += v.y; return *this; }
    Vec2f& operator-=(const Vec2f& v) { x -= v.x; y -= v.y; return *this; }

    Vec2f operator*(KyFloat32 s)const { return Vec2f(x * s, y * s); }
    Vec2f operator/(KyFloat32 d) const { return operator*(1.0f / d); }
    Vec2f operator+(const Vec2f& v) const { return Vec2f(x + v.x, y + v.y); }
    Vec2f operator-(const Vec2f& v) const { return Vec2f(x - v.x, y - v.y); }
    Vec2f operator-() const { return Vec2f(-x, -y); }

    KyFloat32 operator*(const Vec2f& v) const { return x * v.x + y * v.y; } 
    KyFloat32 operator^(const Vec2f& v) const { return x * v.y - y * v.x; } 

    // ------------------------------ Length -----------------------------

    KyFloat32 GetSquareLength() const { return x * x + y * y; }
    KyFloat32 GetLength() const { return Sqrtf(x * x + y * y); }
    KyFloat32 Normalize();
    KyFloat32 GetNormalized(Vec2f& normalized) const;
    Vec2f GetNormalized() const;

    // ------------------------------ Length Shorter Names -----------------------------

    KyFloat32 SqLength() const { return x * x + y * y; }
    KyFloat32 Length() const { return Sqrtf(x * x + y * y); }
    Vec2f Dir() const { return GetNormalized(); }

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

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

    void RotateCCW(KyFloat32 cosAngle, KyFloat32 sinAngle)                     { Set(cosAngle * x - sinAngle * y, sinAngle * x + cosAngle * y); }
    Vec2f GetRotatedCCW(KyFloat32 cosAngle, KyFloat32 sinAngle) const { return Vec2f(cosAngle * x - sinAngle * y, sinAngle * x + cosAngle * y); }

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

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

    // ------------------------------ Zero -----------------------------

    bool IsZero() const { return x == 0.0f && y == 0.0f; }
    static Vec2f Zero()  { return Vec2f(0.0f, 0.0f); } 

    // ------------------------------ Unit -----------------------------

    static Vec2f UnitX() { return Vec2f(1.0f, 0.0f); } 
    static Vec2f UnitY() { return Vec2f(0.0f, 1.0f); } 

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

    KyFloat32 x;
    KyFloat32 y;
};

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

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

// ------------------------------ Global Functions -----------------------------

inline Vec2f operator*(KyFloat32 s, const Vec2f& v) { return Vec2f(v.x * s, v.y * s); } 
inline KyFloat32 DotProduct(const Vec2f& v1, const Vec2f& v2)     { return v1.x * v2.x + v1.y * v2.y; }
inline KyFloat32 CrossProduct(const Vec2f& v1, const Vec2f& v2)   { return v1.x * v2.y - v1.y * v2.x; }
inline KyFloat32 CrossProduct_z(const Vec2f& v1, const Vec2f& v2) { return v1.x * v2.y - v1.y * v2.x; } 

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

// ------------------------------ Distance and Direction ------------------------------

inline KyFloat32 SquareDistance(const Vec2f& A, const Vec2f& B)
{
    const KyFloat32 dx = B.x - A.x;
    const KyFloat32 dy = B.y - A.y;
    return dx * dx + dy * dy;
}

inline KyFloat32 Distance(const Vec2f& A, const Vec2f& B) { return Sqrtf(SquareDistance(A, B)); }

inline Vec2f GetNormalized(const Vec2f& v)
{
    const KyFloat32 length = v.GetLength();
    if (length != 0.0f) // use CanDivideBy()
        return v / length;
    return Vec2f::Zero();
}

inline Vec2f Dir(const Vec2f& A, const Vec2f& B) { return (B - A).GetNormalized(); }

inline bool IsEpsilonZero(const Vec2f& v) { return IsEpsilonZero(v.x) && IsEpsilonZero(v.y); }
inline bool IsEpsilonEqual(const Vec2f& v1, const Vec2f& v2) { return IsEpsilonEqual(v1.x, v2.x) && IsEpsilonEqual(v1.y, v2.y); }
inline bool IsEpsilonDifferent(const Vec2f& A, const Vec2f& B) { return !IsEpsilonEqual(A, B); }

// ------------------------------ Angles and Rotation ------------------------------

inline KyFloat32 GetPositiveAngleCCW(const Vec2f& v1, const Vec2f& v2)
{
    const KyFloat32 sqlenV1 = v1.SqLength();
    const KyFloat32 sqlenV2 = v2.SqLength();
    const KyFloat32 sqlenProd = sqlenV1 * sqlenV2;

    if (sqlenProd != 0.0f)
    {
        const KyFloat32 lenProd = (sqlenProd == 1.0f) ? 1.0f : Sqrtf(sqlenProd);

        const KyFloat32 dp = DotProduct(v1, v2);
        const KyFloat32 angle = Acosf(dp / lenProd);

        const KyFloat32 cp = CrossProduct(v1, v2);
        return cp >= 0.0f ? angle : KY_2_PI - angle;
    }
    else
        return 0.0f;
}

inline KyFloat32 GetPositiveAngleCW(const Vec2f& v1, const Vec2f& v2)
{
    return GetPositiveAngleCCW(v2, v1);
}

inline KyFloat32 GetPositiveAngle(const Vec2f& v1, const Vec2f& v2, Winding::Enum winding)
{
    switch (winding)
    {
    case Winding::CW:  return GetPositiveAngleCW( v1, v2);
    case Winding::CCW: return GetPositiveAngleCCW(v1, v2);
    default:           return GetPositiveAngleCCW(v1, v2);
    }
}

inline KyFloat32 GetSignedAngle(const Vec2f& v1, const Vec2f& v2, Winding::Enum winding)
{
    switch (winding)
    {
    case Winding::CW:  return -GetPositiveAngleCW( v1, v2);
    case Winding::CCW: return  GetPositiveAngleCCW(v1, v2);
    default:           return  GetPositiveAngleCCW(v1, v2);
    }
}

inline void Rotate(Vec2f& v, KyFloat32 cosAngle, KyFloat32 sinAngle) { v.RotateCCW(cosAngle, sinAngle); }

inline Vec2f BisectorCCW(const Vec2f& dir1, const Vec2f& dir2)
{
    KyFloat32 cp = CrossProduct(dir1, dir2);
    if (fabsf(cp) > 0.01f) // not collinear
        return (dir2 - dir1).PerpCW().GetNormalized();
    else // almost collinear
        return cp > 0.0f ? (dir1 + dir2).GetNormalized() : -(dir1 + dir2).GetNormalized();
}

inline Vec2f BisectorCCW(const Vec2f& A, const Vec2f& B, const Vec2f& C)
{
    return BisectorCCW(Dir(B, C), Dir(B, A));
}

inline bool Dir2dLessCCW(const Vec2f& dir_ref, const Vec2f& dir_a, const Vec2f& dir_b)
{
    const KyFloat32 ra = CrossProduct(dir_ref, dir_a);
    const KyFloat32 rb = CrossProduct(dir_ref, dir_b);
    const KyFloat32 ab = CrossProduct(dir_a, dir_b);

    //   rb=0 b=r        // rb=0 b=-r ab=0 a=r // rb=0 b=-r ab=0 a=-r // rb=0 b=-r ab>0   //  rb=0 b=-r ab<0      //
    //                   //                    //                     //      a           //                      //
    //      +-b          //    b-+-r=a         //  a=b-+-r            //    b-+-r         //     b-+-r            //
    //           false   //           true     //           false     //           true  //        a   false      //
    if (rb == 0.0f)
    {
        if (DotProduct(dir_ref, dir_b) > 0.0f)
            return false; // b=r
        if (ab == 0.0f)
            return DotProduct(dir_ref, dir_a) > 0.0f;
        return ab > 0.0f;
    }
    //   rb>0 ra<0       //    rb>0 ra>=0 ab>0   //   rb>0 ra>=0 ab<=0  //
    //      b            //      b a             //    a b              //
    //    --+-r          //    --+-r             //    --+-r            //
    //      a    false   //           true       //           false     //
    if (rb > 0.0f)
    {
        if (ra < 0.0f)
            return false;
        return ab > 0.0f;
    }
    else
    //   rb<0 ra>=0      //   rb<0 ra<0 ab>0     //   rb<0 ra<0 ab<=0     //
    //      a            //                      //                       //
    //    --+-r          //    --+-r             //    --+-r              //
    //      b    true    //    a b    true       //      b a  false       //
    {
        if (ra >= 0.0f)
            return true;
        return ab > 0.0f;
    }
}

inline bool Dir2dLessCW(const Vec2f& dir_ref, const Vec2f& dir_a, const Vec2f& dir_b)
{
    return Dir2dLessCCW(dir_ref, dir_b, dir_a);
}

// ------------------------------ Global Functions Shorter Names -----------------------------

inline KyFloat32 Dot(const Vec2f& v1, const Vec2f& v2)     { return DotProduct(v1, v2); }
inline KyFloat32 Cross_z(const Vec2f& v1, const Vec2f& v2) { return CrossProduct_z(v1, v2); }
inline KyFloat32 Cross(const Vec2f& v1, const Vec2f& v2)   { return CrossProduct(v1, v2); }
inline KyFloat32 SqDist(const Vec2f& A, const Vec2f& B)    { return SquareDistance(A, B); }
inline KyFloat32 Dist(const Vec2f& A, const Vec2f& B)      { return Distance(A, B); }


// ------------------------------ end -----------------------------

inline KyFloat32 Vec2f::Normalize()
{
    const KyFloat32 length = GetLength();
    if (length != 0.0f) // use CanDivideBy()
        operator/=(length);
    else
        Set(0.0f, 0.0f);
    return length;
}

inline KyFloat32 Vec2f::GetNormalized(Vec2f& normalized) const
{
    // don't call Vec2f::Normalize() to avoid LHS
    const KyFloat32 length = GetLength();
    if (length != 0.0f) // use CanDivideBy()
    {
        const KyFloat32 inv_length = 1.0f / length;
        normalized.Set(x * inv_length, y * inv_length);
        return length;
    }
    else
    {
        normalized.Set(0.0f, 0.0f);
        return 0.0f;
    }
}

inline Vec2f Vec2f::GetNormalized() const
{
    const KyFloat32 length = GetLength();
    if (length != 0.0f) // use CanDivideBy()
        return *this / length;
    return Vec2f::Zero();
}

}