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

namespace Kaim
{

class Vec3f
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

    Vec3f() : x(0.0f), y(0.0f), z(0.0f) {}                                    
    Vec3f(KyFloat32 _x, KyFloat32 _y, KyFloat32 _z) : x(_x), y(_y), z(_z) {}  
    explicit Vec3f(const KyFloat32* coords) { Set(coords); }                  
    explicit Vec3f(const Vec2f& v) : x(v.x), y(v.y), z(0.0f) {}               
    Vec3f(const Vec2f& v, KyFloat32 _z) : x(v.x), y(v.y), z(_z) {}            

    void Set(KyFloat32 _x, KyFloat32 _y, KyFloat32 _z) { x = _x; y = _y; z = _z; }        
    void Set(const KyFloat32* coords) { x = coords[0]; y = coords[1]; z = coords[2]; }    
    void Set(const Vec2f& v) { x = v.x; y = v.y; z = 0.0f; }                              
    void Set(const Vec2f& v, KyFloat32 _z) { x = v.x; y = v.y; z = _z; }                  

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

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

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

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

    bool operator<(const Vec3f& v) const; 
    bool operator>(const Vec3f& v) const;
    bool operator<=(const Vec3f& v) const { return !operator>(v); }
    bool operator>=(const Vec3f& v) const { return !operator<(v); }

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

    Vec3f operator+(const Vec3f& v) const { return Vec3f(x + v.x, y + v.y, z + v.z); }
    Vec3f operator-(const Vec3f& v) const { return Vec3f(x - v.x, y - v.y, z - v.z); }
    Vec3f operator-() const { return Vec3f(-x, -y, -z); }

    // -------------------------------- 2d --------------------------------

    Vec3f& operator+=(const Vec2f& v) { x += v.x; y += v.y; return *this; }
    Vec3f& operator-=(const Vec2f& v) { x -= v.x; y -= v.y; return *this; }
    Vec3f operator+(const Vec2f& v) const { return Vec3f(x + v.x, y + v.y, z); }
    Vec3f operator-(const Vec2f& v) const { return Vec3f(x - v.x, y - v.y, z); }

    Vec2f Get2d() const { return Vec2f(x, y); }
    KyFloat32 GetSquareLength2d() const { return x * x + y * y; } 
    KyFloat32 GetLength2d() const { return Sqrtf(x * x + y * y); } 
    KyFloat32 GetNormalized2d(Vec2f& normalized) const; 
    Vec2f GetNormalized2d() const; 

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

    KyFloat32 GetSquareLength() const { return x * x + y * y + z * z; }
    KyFloat32 GetLength() const { return Sqrtf(x * x + y * y + z * z); }
    KyFloat32 Normalize(); 
    KyFloat32 GetNormalized(Vec3f& normalized) const; 
    Vec3f GetNormalized() const;
    bool IsNormalized() const { return IsEpsilonEqual(GetSquareLength(), 1.0f); }

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

    KyFloat32 SqLength() const { return GetSquareLength(); }
    KyFloat32 Length() const { return GetLength(); }
    Vec3f Dir() const { return GetNormalized(); }
    Vec2f Dir2d() const { return GetNormalized2d(); }

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

    Vec3f OffsetX(KyFloat32 dx) const { return Vec3f(x + dx, y, z); } 
    Vec3f OffsetY(KyFloat32 dy) const { return Vec3f(x, y + dy, z); } 
    Vec3f OffsetZ(KyFloat32 dz) const { return Vec3f(x, y, z + dz); } 

    Vec3f Offset2d(KyFloat32 dx, KyFloat32 dy) const { return Vec3f(x + dx, y + dy, z); } 

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

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

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

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

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

    KyFloat32 x;
    KyFloat32 y;
    KyFloat32 z;
};

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

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

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

inline Vec3f operator*(KyFloat32 s, const Vec3f& v) { return Vec3f(v.x * s, v.y * s, v.z * s); }
inline KyFloat32 DotProduct(const Vec3f& v1, const Vec3f& v2) { return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; }
inline KyFloat32 DotProduct2d(const Vec3f& v1, const Vec3f& v2) { return v1.x * v2.x + v1.y * v2.y; } 
inline KyFloat32 CrossProduct_x(const Vec3f& v1, const Vec3f& v2) { return v1.y * v2.z - v1.z * v2.y; }
inline KyFloat32 CrossProduct_y(const Vec3f& v1, const Vec3f& v2) { return v1.z * v2.x - v1.x * v2.z; }
inline KyFloat32 CrossProduct_z(const Vec3f& v1, const Vec3f& v2) { return v1.x * v2.y - v1.y * v2.x; }
inline KyFloat32 CrossProduct2d(const Vec3f& v1, const Vec3f& v2) { return v1.x * v2.y - v1.y * v2.x; }
inline Vec3f CrossProduct(const Vec3f& v1, const Vec3f& v2) { return Vec3f(CrossProduct_x(v1, v2), CrossProduct_y(v1, v2), CrossProduct_z(v1, v2)); }

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

inline Vec3f RightDir(const Vec3f& v) { return CrossProduct(v, Vec3f::UnitZ()).GetNormalized(); }

inline KyFloat32 SquareDistance(const Vec3f& A, const Vec3f& B) { return Seg(A, B).GetSquareLength(); }
inline KyFloat32 SquareDistance2d(const Vec3f& A, const Vec3f& B) { return Seg(A, B).GetSquareLength2d(); }

inline KyFloat32 Distance(const Vec3f& A, const Vec3f& B) { return Sqrtf(SquareDistance(A, B)); }
inline KyFloat32 Distance2d(const Vec3f& A, const Vec3f& B) { return Sqrtf(SquareDistance2d(A, B)); }
inline Vec3f Dir(const Vec3f& A, const Vec3f& B) { return Seg(A, B).GetNormalized(); } 
inline Vec2f Dir2d(const Vec3f& A, const Vec3f& B) { return Vec2f(B.x - A.x, B.y - A.y).GetNormalized(); } 

inline bool IsEpsilonEqual(const Vec3f& A, const Vec3f& B)   { return IsEpsilonEqual(A.x, B.x) && IsEpsilonEqual(A.y, B.y) && IsEpsilonEqual(A.z, B.z); }
inline bool IsEpsilonEqual2d(const Vec3f& A, const Vec3f& B) { return IsEpsilonEqual(A.x, B.x) && IsEpsilonEqual(A.y, B.y); }
inline bool IsEpsilonDifferent(const Vec3f& A, const Vec3f& B)   { return !IsEpsilonEqual(A, B); }
inline bool IsEpsilonDifferent2d(const Vec3f& A, const Vec3f& B) { return !IsEpsilonEqual2d(A, B); }

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

inline KyFloat32 Dot(const Vec3f& v1, const Vec3f& v2)     { return DotProduct(v1, v2); }
inline KyFloat32 Dot2d(const Vec3f& v1, const Vec3f& v2)   { return DotProduct2d(v1, v2); }
inline KyFloat32 Cross_x(const Vec3f& v1, const Vec3f& v2) { return CrossProduct_x(v1, v2); }
inline KyFloat32 Cross_y(const Vec3f& v1, const Vec3f& v2) { return CrossProduct_y(v1, v2); }
inline KyFloat32 Cross_z(const Vec3f& v1, const Vec3f& v2) { return CrossProduct_z(v1, v2); }
inline KyFloat32 Cross2d(const Vec3f& v1, const Vec3f& v2) { return CrossProduct2d(v1, v2); }
inline Vec3f Cross(const Vec3f& v1, const Vec3f& v2)       { return CrossProduct(v1, v2); }
inline KyFloat32 SqDist(const Vec3f& A, const Vec3f& B)    { return SquareDistance(A, B); }
inline KyFloat32 SqDist2d(const Vec3f& A, const Vec3f& B)  { return SquareDistance2d(A, B); }
inline KyFloat32 Dist(const Vec3f& A, const Vec3f& B)      { return Distance(A, B); }
inline KyFloat32 Dist2d(const Vec3f& A, const Vec3f& B)    { return Distance2d(A, B); }

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

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

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

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

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

inline Vec3f Vec3f::GetNormalized() const
{
    Vec3f normalized;
    GetNormalized(normalized);
    return normalized;
}

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

inline Vec2f Vec3f::GetNormalized2d() const
{
    const KyFloat32 length = GetLength2d();
    if (length != 0.0f) // use CanDivideBy()
    {
        const KyFloat32 invLength = 1.0f / length;
        return Vec2f(x * invLength, y * invLength);
    }
    else
    {
        return Vec2f(0.0f, 0.0f);
    }
}


}