vec2f.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_Vec2f_H
#define Navigation_Vec2f_H


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


namespace Kaim
{

class Vec2f
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

    Vec2f() : x(0.0f), y(0.0f) {}

    Vec2f(KyFloat32 _x, KyFloat32 _y) : x(_x), y(_y) {}

    explicit Vec2f(KyFloat32* coords) { Set(coords); }

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

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


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

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

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

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

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

    KY_INLINE bool operator<(const Vec2f& v) const;
    KY_INLINE bool operator>(const Vec2f& v) const;
    KY_INLINE bool operator<=(const Vec2f& v) const;
    KY_INLINE bool operator>=(const Vec2f& v) const;

    KY_INLINE Vec2f& operator*=(KyFloat32 s)    { x *= s; y *= s; return *this; }

    KY_INLINE Vec2f& operator/=(KyFloat32 d)    { return operator*=(1.0f / d); }

    KY_INLINE Vec2f& operator+=(const Vec2f& v) { x += v.x; y += v.y; return *this; }

    KY_INLINE Vec2f& operator-=(const Vec2f& v) { x -= v.x; y -= v.y; return *this; }

    KY_INLINE Vec2f operator*(KyFloat32 s)const { return Vec2f(x * s, y * s); }

    KY_INLINE Vec2f operator/(KyFloat32 d) const { return operator*(1.0f / d); }

    KY_INLINE Vec2f operator+(const Vec2f& v) const { return Vec2f(x + v.x, y + v.y); }

    KY_INLINE Vec2f operator-(const Vec2f& v) const { return Vec2f(x - v.x, y - v.y); }

    KY_INLINE Vec2f operator-() const { return Vec2f(-x, -y); }

    KY_INLINE KyFloat32 operator*(const Vec2f& v) const { return x * v.x + y * v.y; } // DOT PRODUCT

    KY_INLINE KyFloat32 operator^(const Vec2f& v) const { return x * v.y - y * v.x; } // CROSS PRODUCT


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

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

    KY_INLINE KyFloat32 GetLength() const { return Sqrtf(x * x + y * y); }

    KY_INLINE KyFloat32 Normalize();

    KY_INLINE KyFloat32 GetNormalized(Vec2f& normalized) const;

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

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


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

    static KY_INLINE Vec2f Zero() { return Vec2f(0.0f, 0.0f); }

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

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


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

    KyFloat32 x; 
    KyFloat32 y; 
};

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

// ----------------------------------- global functions -----------------------------------
KY_INLINE Vec2f operator*(KyFloat32 s, const Vec2f& v) { return Vec2f(v.x * s, v.y * s); }

KY_INLINE KyFloat32 DotProduct(const Vec2f& v1, const Vec2f& v2) { return (v1.x * v2.x + v1.y * v2.y); }

KY_INLINE KyFloat32 CrossProduct(const Vec2f& v1, const Vec2f& v2) { return v1 ^ v2; }


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

KY_INLINE KyFloat32 Distance(const Vec2f& v1, const Vec2f& v2)
{
    return Sqrtf(SquareDistance(v1, v2));
}

KY_INLINE Vec2f GetDir2d(const Vec2f& v1, const Vec2f& v2)
{
    Vec2f AB = v2 - v1;
    AB.Normalize();
    return AB;
}

KY_INLINE KyFloat32 GetAngleRad(const Vec2f& v1, const Vec2f& v2)
{
    const KyFloat32 sqLengthV1 = v1.GetSquareLength();
    const KyFloat32 sqLengthV2 = v2.GetSquareLength();
    const KyFloat32 sqLengthProd = sqLengthV1 * sqLengthV2;

    if (sqLengthProd > 0.0f)
    {
        const KyFloat32 lengthProd = (sqLengthProd == 1.0f) ? 1.0f : Sqrtf(sqLengthProd);

        const KyFloat32 dotProd = v1 * v2;
        KyFloat32 angleRad = Kaim::Acosf(dotProd / lengthProd);

        const KyFloat32 crossProd = v1 ^ v2;
        return ((crossProd >= 0.0f) ? angleRad : (KY_2_PI - angleRad));
    }
    else
        return 0.0f;
}

KY_INLINE void Rotate(Vec2f& direction, KyFloat32 cosAngle, KyFloat32 sinAngle)
{
    const KyFloat32 formerDirX = direction.x;
    direction.x = cosAngle * formerDirX - sinAngle * direction.y;
    direction.y = sinAngle * formerDirX + cosAngle * direction.y;
}


// ----------------------------------- inline implementation -----------------------------------

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

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

KY_INLINE bool Vec2f::operator<=(const Vec2f& v) const { return !operator>(v); }
KY_INLINE bool Vec2f::operator>=(const Vec2f& v) const { return !operator<(v); }


KY_INLINE KyFloat32 Vec2f::Normalize()
{
    const KyFloat32 length = GetLength();
    if (length != 0.0f)
        operator/=(length);
    return length;
}


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



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

} // namespace Kaim

#endif