Vector

/*
-----------------------------------------------------------------------------
Filename: Vector.hpp
-----------------------------------------------------------------------------

-----------------------------------------------------------------------------
*/

// Declare Once
#pragma once

// Namespace ------------------------------------------------------------------------------
namespace Engine
{
    // Data types -------------------------------------------------------------------------
    // 2D Vector --------------------------------------------------------------------------
    struct float2
    {
    public:
        // Variables
        float x, y;

        // Constructors
        float2();
        float2(float2&);
        float2(float);
        float2(float, float);

        // Casting (not used)
        // Assignment operators
        float2& operator = (float2&);
        float2& operator += (float2&);
        float2& operator -= (float2&);
        float2& operator *= (float2&);
        float2& operator /= (float2&);
        float2& operator *= (float);
        float2& operator /= (float);

        // Unary operators
        float2 operator + ();
        float2 operator - ();

        // Binary operators
        float2 operator + (float2&);
        float2 operator - (float2&);
        float2 operator * (float2&);
        float2 operator / (float2&);
        float2 operator * (float);
        float2 operator / (float);

        // Boolean operators
        bool operator == (float2&);
        bool operator != (float2&);
    };

    // 3D Vector --------------------------------------------------------------------------
    struct float3
    {
    public:
        // Variables
        float x, y, z;

        // Constructors
        float3();
        float3(float3&);
        float3(float);
        float3(float2&, float);
        float3(float, float, float);

        // Casting (not used)
        // Assignment operators
        float3& operator = (float3&);
        float3& operator += (float3&);
        float3& operator -= (float3&);
        float3& operator *= (float3&);
        float3& operator /= (float3&);
        float3& operator *= (float);
        float3& operator /= (float);

        // Unary operators
        float3 operator + ();
        float3 operator - ();

        // Binary operators
        float3 operator + (float3&);
        float3 operator - (float3&);
        float3 operator * (float3&);
        float3 operator / (float3&);
        float3 operator * (float);
        float3 operator / (float);

        // Boolean operators
        bool operator == (float3&);
        bool operator != (float3&);
    };

    // 4D Vector --------------------------------------------------------------------------
    struct float4
    {
    public:
        // Variables
        float x, y, z, w;

        // Constructors
        float4();
        float4(float4&);
        float4(float);
        float4(float2&, float2&);
        float4(float3&, float);
        float4(float2&, float, float);
        float4(float, float, float, float);

        // Casting (not used)
        // Assignment operators
        float4& operator = (float4&);
        float4& operator += (float4&);
        float4& operator -= (float4&);
        float4& operator *= (float4&);
        float4& operator /= (float4&);
        float4& operator *= (float);
        float4& operator /= (float);

        // Unary operators
        float4 operator + ();
        float4 operator - ();

        // Binary operators
        float4 operator + (float4&);
        float4 operator - (float4&);
        float4 operator * (float4&);
        float4 operator / (float4&);
        float4 operator * (float);
        float4 operator / (float);

        // Boolean operators
        bool operator == (float4&);
        bool operator != (float4&);
    };

    // Class definition -------------------------------------------------------------------
    class Vector
    {
    private:
        // Hide constructors (Static class)
        Vector();
        Vector(const Vector&);
        ~Vector();

    public:
        // Length
        static float Length(float2&);
        static float Length(float3&);
        static float Length(float4&);

        // Length Squared
        static float LengthSquared(float2&);
        static float LengthSquared(float3&);
        static float LengthSquared(float4&);

        // Normalization (return vector)
        static float2 Normalize(float2&);
        static float3 Normalize(float3&);
        static float4 Normalize(float4&);

        // Normilzation (return length)
        static float NormalizeLength(float2&);
        static float NormalizeLength(float3&);
        static float NormalizeLength(float4&);

        // Dot Product
        static float Dot(float2&, float2&);
        static float Dot(float3&, float3&);
        static float Dot(float4&, float4&);

        // Cross Product
        static float3 Cross(float3&, float3&);

        // Linear interpolation
        static float2 Lerp(float2&, float2&, float);
        static float3 Lerp(float3&, float3&, float);
        static float4 Lerp(float4&, float4&, float);
    };

    // Default constructor ----------------------------------------------------------------
    Vector::Vector()
    {
    }

    // Default copy constructor -----------------------------------------------------------
    Vector::Vector(const Vector& other)
    {
    }

    // Default deconstructor --------------------------------------------------------------
    Vector::~Vector()
    {
    }

    // Constructors -----------------------------------------------------------------------
    // 2D Vector --------------------------------------------------------------------------
    // Empty constructor  -----------------------------------------------------------------
    float2::float2()
    {
        // Create an empty vector
        x = 0;
        y = 0;
    }

    // Copy constructor -------------------------------------------------------------------
    float2::float2(float2& v)
    {
        // Copy the contents
        x = v.x;
        y = v.y;
    }

    // Uniform constructor ----------------------------------------------------------------
    float2::float2(float s)
    {
        // Set all values to single value
        x = s;
        y = s;
    }

    // Explicit constructor ---------------------------------------------------------------
    float2::float2(float fx, float fy)
    {
        // Set each value explicitely
        x = fx;
        y = fy;
    }

    // 3D Vector --------------------------------------------------------------------------
    // Empty constructor  -----------------------------------------------------------------
    float3::float3()
    {
        // Create an empty vector
        x = 0;
        y = 0;
        z = 0;
    }

    // Copy constructor -------------------------------------------------------------------
    float3::float3(float3& v)
    {
        // Copy the contents
        x = v.x;
        y = v.y;
        z = v.z;
    }

    // Uniform constructor ----------------------------------------------------------------
    float3::float3(float s)
    {
        // Set all values to single value
        x = s;
        y = s;
        z = s;
    }

    // float2 expansion ----------------------------------------------------------------
    float3::float3(float2& v, float fz)
    {
        // Expand a float2 into a float3
        x = v.x;
        y = v.y;
        z = fz;
    }

    // Explicit constructor ---------------------------------------------------------------
    float3::float3(float fx, float fy, float fz)
    {
        // Set each value explicitely
        x = fx;
        y = fy;
        z = fz;
    }

    // 4D Vector --------------------------------------------------------------------------
    // Empty constructor  -----------------------------------------------------------------
    float4::float4()
    {
        // Create an empty vector
        x = 0.0f;
        y = 0.0f;
        z = 0.0f;
        w = 0.0f;
    }

    // Copy constructor -------------------------------------------------------------------
    float4::float4(float4& v)
    {
        // Copy the contents
        x = v.x;
        y = v.y;
        z = v.z;
        w = v.w;
    }

    // Uniform constructor ----------------------------------------------------------------
    float4::float4(float s)
    {
        // Set all values to a single value
        x = s;
        y = s;
        z = s;
        w = s;
    }

    // float2 expansion ----------------------------------------------------------------
    float4::float4(float2& v, float fz, float fw)
    {
        // Expand a float2 into a float4
        x = v.x;
        y = v.y;
        z = fz;
        w = fw;
    }

    // float2 combining ----------------------------------------------------------------
    float4::float4(float2& v1, float2& v2)
    {
        // Combines two float2 vectors into a float4
        x = v1.x;
        y = v1.y;
        z = v2.x;
        w = v2.y;
    }

    // float3 expansion ----------------------------------------------------------------
    float4::float4(float3& v, float fw)
    {
        // Expand a float3 into a float4
        x = v.x;
        y = v.y;
        z = v.z;
        w = fw;
    }

    // Explicit constructor ---------------------------------------------------------------
    float4::float4(float fx, float fy, float fz, float fw)
    {
        // Set each value excplitely
        x = fx;
        y = fy;
        z = fz;
        w = fw;
    }

    // Operator Functions -----------------------------------------------------------------
    // Vector assignment ------------------------------------------------------------------
    inline float2& float2::operator = (float2& v)
    {
        x = v.x;
        y = v.y;

        return *this;
    }
    //--//
    inline float3& float3::operator = (float3& v)
    {
        x = v.x;
        y = v.y;
        z = v.z;

        return *this;
    }
    //--//
    inline float4& float4::operator = (float4& v)
    {
        x = v.x;
        y = v.y;
        z = v.z;
        w = v.w;

        return *this;
    }

    // Addition assignment ----------------------------------------------------------------
    inline float2& float2::operator += (float2& v)
    {
        x = v.x;
        y = v.y;

        return *this;
    }
    //--//
    inline float3& float3::operator += (float3& v)
    {
        x += v.x;
        y += v.y;
        z += v.z;

        return *this;
    }
    //--//
    inline float4& float4::operator += (float4& v)
    {
        x += v.x;
        y += v.y;
        z += v.z;
        w += v.w;

        return *this;
    }

    // Subtraction assignment -------------------------------------------------------------
    inline float2& float2::operator -= (float2& v)
    {
        x -= v.x;
        y -= v.y;

        return *this;
    }
    //--//
    inline float3& float3::operator -= (float3& v)
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;

        return *this;
    }
    //--//
    inline float4& float4::operator -= (float4& v)
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        w -= v.w;

        return *this;
    }

    // Multiplication assignment ----------------------------------------------------------
    inline float2& float2::operator *= (float2& v)
    {
        x *= v.x;
        y *= v.y;

        return *this;
    }
    //--//
    inline float3& float3::operator *= (float3& v)
    {
        x *= v.x;
        y *= v.y;
        z *= v.z;

        return *this;
    }
    //--//
    inline float4& float4::operator *= (float4& v)
    {
        x *= v.x;
        y *= v.y;
        z *= v.z;
        w *= v.w;

        return *this;
    }

    // Divison assignment -----------------------------------------------------------------
    inline float2& float2::operator /= (float2& v)
    {
        x /= v.x;
        y /= v.y;

        return *this;
    }
    //--//
    inline float3& float3::operator /= (float3& v)
    {
        x /= v.x;
        y /= v.y;
        z /= v.z;

        return *this;
    }
    //--//
    inline float4& float4::operator /= (float4& v)
    {
        x /= v.x;
        y /= v.y;
        z /= v.z;
        w /= v.w;

        return *this;
    }

    // Scalar multiplication assignment ---------------------------------------------------
    inline float2& float2::operator *= (float s)
    {
        x *= s;
        y *= s;

        return *this;
    }
    //--//
    inline float3& float3::operator *= (float s)
    {
        x += s;
        y += s;
        z += s;

        return *this;
    }
    //--//
    inline float4& float4::operator *= (float s)
    {
        x += s;
        y += s;
        z += s;
        w += s;

        return *this;
    }

    // Scalar division assignment ---------------------------------------------------------
    inline float2& float2::operator /= (float s)
    {
        x /= s;
        y /= s;

        return *this;
    }
    //--//
    inline float3& float3::operator /= (float s)
    {
        x /= s;
        y /= s;
        z /= s;

        return *this;
    }
    //--//
    inline float4& float4::operator /= (float s)
    {
        x /= s;
        y /= s;
        z /= s;
        w /= s;

        return *this;
    }

    // Positive ---------------------------------------------------------------------------
    inline float2 float2::operator + ()
    {
        return *this;
    }
    //--//
    inline float3 float3::operator + ()
    {
        return *this;
    }
    //--//
    inline float4 float4::operator + ()
    {
        return *this;
    }

    // Negative ---------------------------------------------------------------------------
    inline float2 float2::operator - ()
    {
        return (-x, -y);
    }
    //--//
    inline float3 float3::operator - ()
    {
        return (-x, -y, -z);
    }
    //--//
    inline float4 float4::operator - ()
    {
        return (-x, -y, -z, -w);
    }

    // Addition ---------------------------------------------------------------------------
    inline float2 float2::operator + (float2& v)
    {
        return (x + v.x, y + v.y);
    }
    //--//
    inline float3 float3::operator + (float3& v)
    {
        return (x + v.x, y + v.y, z + v.z);
    }
    //--//
    inline float4 float4::operator + (float4& v)
    {
        return (x + v.x, y + v.y, z + v.z, w + v.w);
    }

    // Subtraction ------------------------------------------------------------------------
    inline float2 float2::operator - (float2& v)
    {
        return (x - v.x, y - v.y);
    }
    //--//
    inline float3 float3::operator - (float3& v)
    {
        return (x - v.x, y - v.y, z - v.z);
    }
    //--//
    inline float4 float4::operator - (float4& v)
    {
        return (x - v.x, y - v.y, z - v.z, w - v.z);
    }

    // Multiplication ---------------------------------------------------------------------
    inline float2 float2::operator * (float2& v)
    {
        return (x * v.x, y * v.y);
    }
    //--//
    inline float3 float3::operator * (float3& v)
    {
        return (x * v.x, y * v.y, z * v.z);
    }
    //--//
    inline float4 float4::operator * (float4& v)
    {
        return (x * v.x, y * v.y, z * v.z, w * v.w);
    }

    // Division ---------------------------------------------------------------------------
    inline float2 float2::operator / (float2& v)
    {
        return (x / v.x, y / v.y);
    }
    //--//
    inline float3 float3::operator / (float3& v)
    {
        return (x / v.x, y / v.y, z / v.z);
    }
    //--//
    inline float4 float4::operator / (float4& v)
    {
        return (x / v.x, y / v.y, z / v.z, w / v.z);
    }

    // Scalar multiplication --------------------------------------------------------------
    inline float2 float2::operator * (float s)
    {
        return (x * s, y * s);
    }
    //--//
    inline float3 float3::operator * (float s)
    {
        return (x * s, y * s, z * s);
    }
    //--//
    inline float4 float4::operator * (float s)
    {
        return (x * s, y * s, z * s, w * s);
    }

    // Scalar division --------------------------------------------------------------------
    inline float2 float2::operator / (float s)
    {
        return (x / s, y / s);
    }
    //--//
    inline float3 float3::operator / (float s)
    {
        return (x / s, y / s, z / s);
    }
    //--//
    inline float4 float4::operator / (float s)
    {
        return (x / s, y / s, z / s, w / s);
    }

    // Equals comparison ------------------------------------------------------------------
    inline bool float2::operator == (float2& v)
    {
        return x == v.x && y == v.y;
    }
    //--//
    inline bool float3::operator == (float3& v)
    {
        return x == v.x && y == v.y && z == v.z;
    }
    //--//
    inline bool float4::operator == (float4& v)
    {
        return x == v.x && y == v.y && z == v.z && w == v.w;
    }

    // Not Equals comparison ---------------------------------------------------------------
    inline bool float2::operator != (float2& v)
    {
        return x != v.x || y != v.y;
    }
    //--//
    inline bool float3::operator != (float3& v)
    {
        return x != v.x || y != v.y || z != v.z;
    }
    //--//
    inline bool float4::operator != (float4& v)
    {
        return x != v.x || y != v.y || z != v.z || w != v.w;
    }

    // Vector Functions -------------------------------------------------------------------
    // Length -----------------------------------------------------------------------------
    inline float Vector::Length(float2& v)
    {
        return sqrtf(v.x * v.x + v.y * v.y);
    }
    //--//
    inline float Vector::Length(float3& v)
    {
        return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
    }
    //--//
    inline float Vector::Length(float4& v)
    {
        return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w);
    }

    // Length squared ---------------------------------------------------------------------
    inline float Vector::LengthSquared(float2& v)
    {
        return v.x * v.x + v.y * v.y;
    }
    //--//
    inline float Vector::LengthSquared(float3& v)
    {
        return v.x * v.x + v.y * v.y + v.z * v.z;
    }
    //--//
    inline float Vector::LengthSquared(float4& v)
    {
        return v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
    }

    // Normalize --------------------------------------------------------------------------
    inline float2 Vector::Normalize(float2& v)
    {
        return (v / Length(v));
    }
    //--//
    inline float3 Vector::Normalize(float3& v)
    {
        return (v / Length(v));
    }
    //--//
    inline float4 Vector::Normalize(float4& v)
    {
        return (v / Length(v));
    }

    // Normalize and length ---------------------------------------------------------------
    inline float Vector::NormalizeLength(float2& v)
    {
        float length;
        length = Length(v);
        v /= length;

        return length;
    }
    //--//
    inline float Vector::NormalizeLength(float3& v)
    {
        float length;
        length = Length(v);
        v /= length;

        return length;
    }
    //--//
    inline float Vector::NormalizeLength(float4& v)
    {
        float length;
        length = Length(v);
        v /= length;

        return length;
    }

    // Dot Product ------------------------------------------------------------------------
    inline float Vector::Dot(float2& v1, float2& v2)
    {
        return v1.x * v2.x + v1.y * v2.y;
    }
    //--//
    inline float Vector::Dot(float3& v1, float3& v2)
    {
        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
    }
    //--//
    inline float Vector::Dot(float4& v1, float4& v2)
    {
        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w;
    }

    // Cross Product ----------------------------------------------------------------------
    inline float3 Vector::Cross(float3& v1, float3& v2)
    {
        return (v1.y * v2.z - v1.z * v2.y,
                v1.z * v2.x - v1.x * v2.z,
                v1.x * v2.y - v1.y * v2.x);

    }

    // Linear interpolation ---------------------------------------------------------------
    inline float2 Vector::Lerp(float2& v1, float2& v2, float s)
    {
        return (v1.x + s * (v2.x - v1.x),
                v1.y + s * (v2.y - v1.y));
    }
    //--//
    inline float3 Vector::Lerp(float3& v1, float3& v2, float s)
    {
        return (v1.x + s * (v2.x - v1.x),
                v1.y + s * (v2.y - v1.y),
                v1.z + s * (v2.z - v1.z));
    }
    //--//
    inline float4 Vector::Lerp(float4& v1, float4& v2, float s)
    {
        return (v1.x + s * (v2.x - v1.x),
                v1.y + s * (v2.y - v1.y),
                v1.z + s * (v2.z - v1.z),
                v1.w + s * (v2.w - v1.w));
    }
}