vec3i.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_Vec3i_H
#define Navigation_Vec3i_H

#include "gwnavruntime/math/vec2i.h"


namespace Kaim
{


class Vec3i
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

    Vec3i() : x(0), y(0), z(0) {}

    Vec3i(KyInt32 _x, KyInt32 _y, KyInt32 _z) : x(_x), y(_y), z(_z) {}

    explicit Vec3i(KyInt32* coords) { Set(coords); }

    KY_INLINE void Set(KyInt32 _x, KyInt32 _y, KyInt32 _z) { x = _x; y = _y; z = _z; }
    
    KY_INLINE void Set(const Vec2i& v, KyInt32 _z) { x = v.x; y = v.y; z = _z; }
    
    KY_INLINE void Set(KyInt32* coords) { x = coords[0]; y = coords[1]; z = coords[2]; }


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

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

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

    bool operator<(const Vec3i& 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);
    }

    KY_INLINE Vec3i& operator*=(KyInt32 s) { x *= s; y *= s; z *= s; return *this; }
    
    KY_INLINE Vec3i& operator/=(KyInt32 d) { x /= d; y /= d; z /= d; return *this; }
    
    KY_INLINE Vec3i& operator+=(const Vec3i& v) { x += v.x; y += v.y; z += v.z; return *this; }
    
    KY_INLINE Vec3i& operator-=(const Vec3i& v) { x -= v.x; y -= v.y; z -= v.z; return *this; }

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

    KY_INLINE KyInt32 operator*(const Vec3i& v) const { return x * v.x + y * v.y + z * v.z; } // DOT PRODUCT
    
    KY_INLINE Vec3i operator^(const Vec3i& v) const { return Vec3i( (y * v.z - z * v.y), (z * v.x - x * v.z), (x * v.y - y * v.x) ); } // CROSS PRODUCT


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

    KY_INLINE KyInt32 Orient2d(const Vec3i& A, const Vec3i& B) const { return (A.x - x) * (B.y - y) - (B.x - x) * (A.y - y); }

    KY_INLINE bool IsOnLeftSide(const Vec3i& A, const Vec3i& B) const { return Orient2d(A, B) >= 0; }

    KY_INLINE bool IsStrictlyOnLeftSide(const Vec3i& A, const Vec3i& B) const { return Orient2d(A, B) > 0; }

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


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

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

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

    static KY_INLINE Vec3i UnitZ() { return Vec3i(0, 0, 1); }


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

    KyInt32 x; 
    KyInt32 y; 
    KyInt32 z; 
};

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


}


#endif