tb_vector.h

#ifndef _TurtleBrains_Vector_h_
#define _TurtleBrains_Vector_h_

#include "../core/tb_configuration.h"
#include "../core/tb_error.h"
#include "../core/tb_defines.h" //For tb_unsused
#include "tb_math.h"

namespace TurtleBrains
{
    namespace Math
    {

        enum SkipInitialization { kSkipInitialization = 0, };

        enum VectorComponent
        {
            kComponentX = 0, 
            kComponentY,     
            kComponentZ,     
            kComponentW      
        };

        class Vector2
        {
        public:
            static const Vector2 kZero;

            union
            {
                float mComponents[2];
                struct { float x, y; };
            };

            inline explicit Vector2(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }

            inline Vector2(void) :
                x(0.0f),
                y(0.0f)
            {
            }

            inline Vector2(const float valueX, const float valueY) :
                x(valueX),
                y(valueY)
            {
            }

            inline Vector2(const Vector2& other) :
                x(other.x),
                y(other.y)
            {
            }

            inline ~Vector2(void)
            {
            }

            inline Vector2& operator=(const Vector2& other)
            {
                if (&other != this)
                {
                    x = other.x;
                    y = other.y;
                }
                return *this;
            }

            inline bool operator==(const Vector2& other) const
            {
                return (true == IsEqual(x, other.x) && true == IsEqual(y, other.y)) ? true : false;
            }

            inline bool operator!=(const Vector2& other) const
            {
                return (true == operator==(other)) ? false : true;
            }

            inline operator const float*(void) const { return mComponents; }

            inline operator float*(void) { return mComponents; }

            inline const float& operator[](const size_t index) const { return mComponents[index]; }

            inline float& operator[](const size_t index) { return mComponents[index]; }

#ifndef tb_math_less_operators
            inline Vector2 operator+(const Vector2& rightSide) const    {   return Vector2(x + rightSide.x, y + rightSide.y);   }

            inline Vector2& operator+=(const Vector2& rightSide)        {   x += rightSide.x, y += rightSide.y; return *this;   }

            inline Vector2 operator-(const Vector2& rightSide) const    {   return Vector2(x - rightSide.x, y - rightSide.y);   }

            inline Vector2& operator-=(const Vector2& rightSide)        {   x -= rightSide.x, y -= rightSide.y; return *this;   }

            inline Vector2 operator*(float scalar) const                {   return Vector2(x * scalar, y * scalar); }

            friend Vector2 operator*(float scalar, const Vector2& rightSide) { return Vector2(scalar * rightSide.x, scalar * rightSide.y); }

            inline Vector2& operator*=(float scalar)                {   x *= scalar;    y *= scalar;    return *this;   }

            inline Vector2 operator/(float scalar) const            {   return Vector2(x / scalar, y / scalar); }

            inline Vector2& operator/=(float scalar)                {   x /= scalar;    y /= scalar;    return *this;   }

            inline Vector2 operator-(void) const                {   return Vector2(-x, -y);     }

            inline float operator*(const Vector2 &rhs) const    {   return (x * rhs.x) + (y * rhs.y);   }

            inline float Magnitude(void) const { return sqrt((x * x) + (y * y)); }

            inline float MagnitudeSquared(void) const { return (x * x) + (y * y); }

            inline Vector2 GetNormalized(void) const
            {
                const float magnitude(Magnitude()); 
                if (true == IsZero(magnitude)) { return kZero; }
                return Vector2(x / magnitude, y / magnitude);
            }

            inline float Normalize(void)
            {
                const float magnitude(Magnitude()); 
                if (false == IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                }
                return magnitude;
            }

            inline void Scale(float scalar) { *this *= scalar; }

            inline void SetLength(float length) { Normalize(); *this *= length; }
#endif
        };

//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//

        class Vector3
        {
        public:
            static const Vector3 kZero;

            union
            {
                float mComponents[3];
                struct { float x, y, z; };
            };

            inline explicit Vector3(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }

            Vector3(void) :
                x(0.0f),
                y(0.0f),
                z(0.0f)
            {
            }

            inline Vector3(const float valueX, const float valueY, const float valueZ) :
                x(valueX),
                y(valueY),
                z(valueZ)
            {
            }

            inline explicit Vector3(const Vector2& other, const float valueZ) :
                x(other.x),
                y(other.y),
                z(valueZ)
            {
            }

            Vector3(const Vector3& other) :
                x(other.x),
                y(other.y),
                z(other.z)
            {
            }

            ~Vector3(void)
            {
            }

            inline Vector3& operator=(const Vector3& other)
            {
                if (&other != this)
                {
                    x = other.x;
                    y = other.y;
                    z = other.z;
                }
                return *this;
            }

            //
            // TODO: TIM: Planning: Would this be useful to have, or just dangerous?
            //
            //inline Vector3& operator=(const Vector2 &v)
            //{
            //  x = v.x;    y = v.y; /* z = z; */
            //  return (*this);
            //}

            inline bool operator==(const Vector3& other) const
            {
                return (true == IsEqual(x, other.x) && true == IsEqual(y, other.y) && true == IsEqual(z, other.z)) ? true : false;
            }

            inline bool operator!=(const Vector3& other) const
            {
                return (true == operator==(other)) ? false : true;
            }

            inline operator const float*(void) const { return mComponents; }

            inline operator float*(void) { return mComponents; }

            inline const float& operator[](const size_t index) const { return mComponents[index]; }

            inline float& operator[](const size_t index) { return mComponents[index]; }

            //TODO: TIM: Reconsider: This could be dangerous, do we want to support it?
            //inline operator Vector2(void) { return Vector2(x, y); }

    #ifndef tb_math_less_operators
            inline Vector3 operator+(const Vector3& rightSide) const    {   return Vector3(x + rightSide.x, y + rightSide.y, z + rightSide.z);  }

            inline Vector3& operator+=(const Vector3& rightSide)        {   x += rightSide.x, y += rightSide.y; z += rightSide.z;   return *this;   }

            inline Vector3 operator-(const Vector3& rightSide) const    {   return Vector3(x - rightSide.x, y - rightSide.y, z - rightSide.z);  }

            inline Vector3& operator-=(const Vector3& rightSide)        {   x -= rightSide.x, y -= rightSide.y; z += rightSide.z;   return *this;   }


            inline Vector3 operator*(float scalar) const            {   return Vector3(x * scalar, y * scalar, z * scalar); }

            friend Vector3 operator*(float scalar, const Vector3& rightSide) { return Vector3(scalar * rightSide.x, scalar * rightSide.y, scalar * rightSide.z); }

            inline Vector3& operator*=(float scalar)                {   x *= scalar;    y *= scalar;    z *= scalar;    return *this;   }

            inline Vector3 operator/(float scalar) const            {   return Vector3(x / scalar, y / scalar, z / scalar); }

            inline Vector3& operator/=(float scalar)                {   x /= scalar;    y /= scalar;    z /= scalar;    return *this;   }


            inline Vector3 operator-(void) const                {   return Vector3(-x, -y, -z);     }

            inline float operator*(const Vector3 &rhs) const    {   return (x * rhs.x) + (y * rhs.y) + (z * rhs.z);     }

            inline Vector3 operator^(const Vector3& rightSide) const
            {   
                return Vector3((y * rightSide.z) - (rightSide.y * z), -((x * rightSide.z) - (rightSide.x * z)), (x * rightSide.y) - (rightSide.x * y));
            }


            inline float Magnitude(void) const { return sqrt((x * x) + (y * y) + (z * z)); }

            inline float MagnitudeSquared(void) const { return (x * x) + (y * y) + (z * z); }

            inline Vector3 GetNormalized(void) const
            { 
                const float magnitude(Magnitude());
                if (true == IsZero(magnitude)) { return kZero; }
                return Vector3(x / magnitude, y / magnitude, z / magnitude);
            }

            inline float Normalize(void)
            {
                const float magnitude(Magnitude());
                if (false == IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                    z /= magnitude;
                }
                return magnitude;
            }

            inline void Scale(float scalar) { *this *= scalar; }

            inline void SetLength(float length) { Normalize(); *this *= length; }
    #endif
        };

//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//

        class Vector4
        {
        public:
            static const Vector4 kZero;

            union
            {
                float mComponents[4];
                struct { float x, y, z, w; };
            };

            inline explicit Vector4(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }

            inline Vector4(void) :
                x(0.0f),
                y(0.0f),
                z(0.0f),
                w(0.0f)
            {
            }

            inline Vector4(const float valueX, const float valueY, const float valueZ, const float valueW) :
                x(valueX),
                y(valueY),
                z(valueZ),
                w(valueW)
            {
            }

            inline explicit Vector4(const Vector2& other, const float valueZ, const float valueW) :
                x(other.x),
                y(other.y),
                z(valueZ),
                w(valueW)
            {
            }

            inline explicit Vector4(const Vector3& other, const float valueW) :
                x(other.x),
                y(other.y),
                z(other.z),
                w(valueW)
            {
            }

            inline Vector4(const Vector4& other) :
                x(other.x),
                y(other.y),
                z(other.z),
                w(other.w)
            {
            }

            ~Vector4(void)
            {
            }

            inline Vector4& operator=(const Vector4& other)
            {
                if (&other != this)
                {
                    x = other.x;
                    y = other.y;
                    z = other.z;
                    w = other.w;
                }
                return *this;
            }

            inline bool operator==(const Vector4& other) const
            {
                return (true == IsEqual(x, other.x) && true == IsEqual(y, other.y) &&
                    true == IsEqual(z, other.z) && true == IsEqual(w, other.w)) ? true : false;
            }

            inline bool operator!=(const Vector4& other) const
            {
                return (true == operator==(other)) ? false : true;
            }

            inline operator const float*(void) const { return mComponents; }

            inline operator float*(void) { return mComponents; }

            inline const float& operator[](const size_t index) const { return mComponents[index]; }

            inline float& operator[](const size_t index) { return mComponents[index]; }

            //TODO: TIM: Reconsider: This could be dangerous, do we want to support it?
            //inline operator Vector2(void) { return Vector2(x, y); }
            //inline operator Vector3(void) { return Vector3(x, y, z); }

#ifndef tb_math_less_operators
            inline Vector4 operator+(const Vector4& rightSide) const    {   return Vector4(x + rightSide.x, y + rightSide.y, z + rightSide.z, w + rightSide.w); }

            inline Vector4& operator+=(const Vector4& rightSide)        {   x += rightSide.x, y += rightSide.y; z += rightSide.z;   w += rightSide.w; return *this; }

            inline Vector4 operator-(const Vector4& rightSide) const    {   return Vector4(x - rightSide.x, y - rightSide.y, z - rightSide.z, w - rightSide.w); }

            inline Vector4& operator-=(const Vector4& rightSide)        {   x -= rightSide.x, y -= rightSide.y; z -= rightSide.z; w -= rightSide.w; return *this;   }


            inline Vector4 operator*(float scalar) const                {   return Vector4(x * scalar, y * scalar, z * scalar, w * scalar); }

            friend Vector4 operator*(float scalar, const Vector4& rightSide) { return Vector4(scalar * rightSide.x, scalar * rightSide.y, scalar * rightSide.z, scalar * rightSide.w); }

            inline Vector4& operator*=(float scalar)                    {   x *= scalar;    y *= scalar;    z *= scalar; w *= scalar;   return *this;   }

            inline Vector4 operator/(float scalar) const            {   return Vector4(x / scalar, y / scalar, z / scalar, w / scalar); }

            inline Vector4& operator/=(float scalar)                {   x /= scalar;    y /= scalar;    z /= scalar; w /= scalar;   return *this;   }


            inline Vector4 operator-(void) const                {   return Vector4(-x, -y, -z, -w);     }

            inline float operator*(const Vector4& rightSide) const  {   return (x * rightSide.x) + (y * rightSide.y) + (z * rightSide.z) + (w * rightSide.w);   }

            //TODO: TIM: Reconsider: Does this work, and if it does, how do we want to support it?  Document if needed.
            //inline Vector4 operator^(const Vector4 &rhs) const    {   return Vector4((y * rhs.z) - (rhs.y * z), -((x * rhs.z) - (rhs.x * z)), (x * rhs.y) - (rhs.x * y));  }

            inline float Magnitude(void) const { return sqrt((x * x) + (y * y) + (z * z) + (w * w)); }

            inline float MagnitudeSquared(void) const { return (x * x) + (y * y) + (z * z) + (w * w); }

            inline Vector4 GetNormalized(void) const
            {
                const float magnitude(Magnitude());
                if (true == IsZero(magnitude)) { return kZero; }
                return Vector4(x / magnitude, y / magnitude, z / magnitude, w / magnitude);
            }

            inline float Normalize(void)
            {
                const float magnitude(Magnitude());
                if (false == IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                    z /= magnitude;
                    w /= magnitude;
                }
                return magnitude;
            }

            inline void Scale(float scalar) { *this *= scalar; }

            inline void SetLength(float length) { Normalize(); *this *= length; }
#endif
        };

//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//

        inline Vector2* Vector2Add(Vector2* result, const Vector2* leftSide, const Vector2* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x + rightSide->x;
            result->y = leftSide->y + rightSide->y;
            return result;
        }

        inline Vector3* Vector3Add(Vector3* result, const Vector3* leftSide, const Vector3* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x + rightSide->x;
            result->y = leftSide->y + rightSide->y;
            result->z = leftSide->z + rightSide->z;
            return result;
        }

        inline Vector4* Vector4Add(Vector4* result, const Vector4* leftSide, const Vector4* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x + rightSide->x;
            result->y = leftSide->y + rightSide->y;
            result->z = leftSide->z + rightSide->z;
            result->w = leftSide->w + rightSide->w;
            return result;
        }

        inline Vector2* Vector2Subtract(Vector2* result, const Vector2* leftSide, const Vector2* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x - rightSide->x;
            result->y = leftSide->y - rightSide->y;
            return result;
        }

        inline Vector3* Vector3Subtract(Vector3* result, const Vector3* leftSide, const Vector3* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x - rightSide->x;
            result->y = leftSide->y - rightSide->y;
            result->z = leftSide->z - rightSide->z;
            return result;
        }

        inline Vector4* Vector4Subtract(Vector4* result, const Vector4* leftSide, const Vector4* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");

            result->x = leftSide->x - rightSide->x;
            result->y = leftSide->y - rightSide->y;
            result->z = leftSide->z - rightSide->z;
            result->w = leftSide->w - rightSide->w;
            return result;
        }

        inline Vector2* Vector2Scale(Vector2* result, const Vector2* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x * scalar;
            result->y = input->y * scalar;
            return result;
        }

        inline Vector3* Vector3Scale(Vector3* result, const Vector3* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x * scalar;
            result->y = input->y * scalar;
            result->z = input->z * scalar;
            return result;
        }

        inline Vector4* Vector4Scale(Vector4* result, const Vector4* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x * scalar;
            result->y = input->y * scalar;
            result->z = input->z * scalar;
            result->w = input->w * scalar;
            return result;
        }

        inline Vector2* Vector2ScaleDivide(Vector2* result, const Vector2* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x / scalar;
            result->y = input->y / scalar;
            return result;
        }

        inline Vector3* Vector3ScaleDivide(Vector3* result, const Vector3* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x / scalar;
            result->y = input->y / scalar;
            result->z = input->z / scalar;
            return result;
        }

        inline Vector4* Vector4ScaleDivide(Vector4* result, const Vector4* input, const float scalar)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = input->x / scalar;
            result->y = input->y / scalar;
            result->z = input->z / scalar;
            result->w = input->w / scalar;
            return result;
        }

        inline Vector2* Vector2Negate(Vector2* result, const Vector2* input)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = -input->x;
            result->y = -input->y;
            return result;
        }

        inline Vector3* Vector3Negate(Vector3* result, const Vector3* input)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = -input->x;
            result->y = -input->y;
            result->z = -input->z;
            return result;
        }

        inline Vector4* Vector4Negate(Vector4* result, const Vector4* input)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            result->x = -input->x;
            result->y = -input->y;
            result->z = -input->z;
            result->w = -input->w;
            return result;
        }

        inline float Vector2DotProduct(const Vector2* leftSide, const Vector2* rightSide)
        {
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");
            return (leftSide->x * rightSide->x) + (leftSide->y * rightSide->y);
        }

        inline float Vector3DotProduct(const Vector3* leftSide, const Vector3* rightSide)
        {
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");
            return (leftSide->x * rightSide->x) + (leftSide->y * rightSide->y) + (leftSide->z * rightSide->z);
        }

        inline float Vector4DotProduct(const Vector4* leftSide, const Vector4* rightSide)
        {
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");
            return (leftSide->x * rightSide->x) + (leftSide->y * rightSide->y) + (leftSide->z * rightSide->z) + (leftSide->w * rightSide->w);
        }

        inline Vector3* Vector3CrossProduct(Vector3* result, const Vector3* leftSide, const Vector3* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");
            tb_error_if(leftSide == rightSide, "tbExternalError: Invalid parameter; expected leftSide to be different from rightSide.");
            tb_error_if(result == leftSide || result == rightSide, "Invalid parameter; expected result to be different than leftSide and rightSide");

            result->x = ((leftSide->y * rightSide->z) - (rightSide->y * leftSide->z));
            result->y = -(((leftSide->x * rightSide->z) - (rightSide->x * leftSide->z)));
            result->z = ((leftSide->x * rightSide->y) - (rightSide->x * leftSide->y));
            return result;
        }

        inline Vector4* Vector4CrossProduct(Vector4* result, const Vector4* leftSide, const Vector4* rightSide)
        {
            tb_error_if(nullptr == result, "tbExternalError: Invalid parameter for result, expected valid pointer.");
            tb_error_if(nullptr == leftSide, "tbExternalError: Invalid parameter for leftSide, expected valid pointer.");
            tb_error_if(nullptr == rightSide, "tbExternalError: Invalid parameter for rightSide, expected valid pointer.");
            tb_error_if(result == leftSide || result == rightSide, "Invalid parameter; expected result to be different than leftSide and rightSide");

            tb_error_if(true, "Not sure if this is an accurate Vector4 CrossProduct");
            result->x = ((leftSide->y * rightSide->z) - (rightSide->y * leftSide->z));
            result->y = -(((leftSide->x * rightSide->z) - (rightSide->x * leftSide->z)));
            result->z = ((leftSide->x * rightSide->y) - (rightSide->x * leftSide->y));
            result->w = 0.0f;
            return result;
        }

        inline float Vector2Magnitude(const Vector2* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return sqrt((input->x * input->x) + (input->y * input->y));
        }

        inline float Vector3Magnitude(const Vector3* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return sqrt((input->x * input->x) + (input->y * input->y) + (input->z * input->z));
        }

        inline float Vector4Magnitude(const Vector4* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return sqrt((input->x * input->x) + (input->y * input->y) + (input->z * input->z) + (input->w * input->w));
        }

        inline float Vector2MagnitudeSquared(const Vector2* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return (input->x * input->x) + (input->y * input->y);
        }

        inline float Vector3MagnitudeSquared(const Vector3* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return (input->x * input->x) + (input->y * input->y) + (input->z * input->z);
        }

        inline float Vector4MagnitudeSquared(const Vector4* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return (input->x * input->x) + (input->y * input->y) + (input->z * input->z) + (input->w * input->w);
        }

        inline Vector2* Vector2Normalize(Vector2* result, const Vector2* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            const float magnitude = Vector2Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
            }
            return result;
        }

        inline Vector3* Vector3Normalize(Vector3* result, const Vector3* input)
        {
            const float magnitude = Vector3Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
                result->z = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
            }
            return result;
        }

        inline Vector4* Vector4Normalize(Vector4* result, const Vector4* input)
        {
            const float magnitude = Vector4Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
                result->z = 0.0f;
                result->w = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
                result->w = input->w / magnitude;
            }
            return result;
        }

        inline Vector2* Vector2NormalizeMagnitude(Vector2* result, const Vector2* input, float& magnitude)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            magnitude = Vector2Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
            }
            return result;
        }

        inline Vector3* Vector3NormalizeMagnitude(Vector3* result, const Vector3* input, float &magnitude)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            magnitude = Vector3Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
                result->z = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
            }
            return result;
        }

        inline Vector4* Vector4NormalizeMag(Vector4* result, const Vector4* input, float &magnitude)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");

            magnitude = Vector4Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = 0.0f;
                result->y = 0.0f;
                result->z = 0.0f;
                result->w = 0.0f;
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
                result->w = input->w / magnitude;
            }
            return result;
        }

        inline float Vector3AngleBetween(const Vector3* left, const Vector3* right)
        {
            const float productOfMagnitudes(Vector3Magnitude(left) * Vector3Magnitude(right));
            if (true == IsZero(productOfMagnitudes)) { return 0.0f; }
            const float value(Vector3DotProduct(left, right) / productOfMagnitudes);
            const float clampedValue((value < -1.0f) ? -1.0f : (value > 1.0f) ? 1.0f  : value); //Clamp: -1.0f <= value <= 1.0f
            return acos(clampedValue);
        }

        static inline Vector3* OrientationToForwardVector3(Vector3 *result, float orientation)
        {
            result->x = sin(orientation);
            result->y = 0.0f;
            result->z = -cos(orientation);

            return result;
        }

        static inline Vector2& OrientationToForwardVector2(Vector2& result, float orientation)
        {
            result.x = sin(orientation);
            result.y = -cos(orientation);
            return result;
        }

        static inline float ForwardVector3ToOrientation(const Vector3& forward)
        {
            Vector3 vZAxis(0.0f, 0.0f, -1.0f);
            float orientation = acos((vZAxis.x * forward.x) + (vZAxis.y * forward.y) + (vZAxis.z * forward.z));
            if (forward.x < 0.0f)
            {
                orientation = fabs(orientation - kTwoPi);
            }
            return orientation;
        }

        static inline float ForwardVector2ToOrientation(const Vector2& forward)
        {
            Vector2 yAxis(0.0f, -1.0f);
            float orientation = acos((yAxis.x * forward.x) + (yAxis.y * forward.y));
            if (forward.x < 0.0f)
            {
                orientation = fabs(orientation - kTwoPi);
            }
            return orientation;
        }

    }; /* namespace Math */
}; /* namespace TurtleBrains */

namespace tbMath = TurtleBrains::Math;

#endif /* _TurtleBrains_Vector_h_ */