tb_vector.hpp

 
#ifndef TurtleBrains_Vector_hpp
#define TurtleBrains_Vector_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_error.hpp>
#include <turtle_brains/core/tb_defines.hpp>
#include <turtle_brains/math/tb_math.hpp>
#include <turtle_brains/math/tb_angle.hpp>
#include <turtle_brains/core/tb_string.hpp>
 
#include <iostream>
 
// 2024-10-30: In July 2022 CyanPhoton exploded my mind with the following visualization technique of cross products. They
//   can be visualized by taking the left-side parameter and drawing an arc to the right-side parameter using the
//   smallest angle between. So axis, X and Y and getting cross(X, Y) would draw the arc in the 90 degree region rather
//   than 270 degrees. This would cause (assuming X is right, and Y is up) a counter-clockwise arc from X to Y. Imagine
//   a (REGULAR/CW TIGHTENING) screw and twist in the direction of the arc, in this case it would loosen and pull out of
//   the plane. This is the direction the cross product will point, and give us the Z axis in a Right-Handed System.
//
// Note: For a left handed system you turn the imaginary screw the other direction so Z would go into the plane).
 
namespace TurtleBrains
{
    namespace Math
    {
        // 2024-12-05: TODO: TurtleBrains: Math: API-BREAK: We need to support tbMath::Vector3 and ice::Vector3 being
        //   different even if iceScalar became float in the future. We also need the Vector3 operator that casts from
        //   Scalar<float> to Scalar<double> etc to be EXPLICIT. I can see we made it implicit because of the amount of
        //   conversions, but I've found physics code that dropped precision because of this implicit behavior. Must avoid.
        //
        //   While digging through this non-sense we should also add a typedef float Scalar; for TurtleBrains which of
        //   course breaks projects that use "Scalar" specifically for iceScalar... ugh. Past Tim didn't feel TurtleBrains
        //   needed a Scalar since it would ALWAYS be float (for graphics), unlike physics which might change float/double
        //   etc... Current Tim thinks it is odd that ONLY Scalar is different between the two. Renaming the Type in all
        //   the math TypedThing<Type> to ScalarType would be a great idea as well since it specifies what it is.
        //
        //   ikiwixz suggests making the Scalar<typename Tag> for the strong typed, which would mean tbScalar and iceScalar
        //   would be different even when both are floats, desired! That would also mean TypedVector3<tbScalar> would
        //   automatically be different from TypedVector3<iceScalar> ... this would require coming up with a TypedScalar<>
 
        //Forward Declarations used in Vector classes.
        //template<typename ScalarType> class TypedVector2;
        //template<typename ScalarType> class TypedVector3;
        //template<typename ScalarType> class TypedVector4;
 
        template<typename Type> class TypedVector2;
        template<typename Type> class TypedVector3;
        template<typename Type> class TypedVector4;
 
        template<typename Type> Type Vector2DotProduct(const TypedVector2<Type>* leftSide, const TypedVector2<Type>* rightSide);
        template<typename Type> Type Vector3DotProduct(const TypedVector3<Type>* leftSide, const TypedVector3<Type>* rightSide);
        template<typename Type> Type Vector4DotProduct(const TypedVector4<Type>* leftSide, const TypedVector4<Type>* rightSide);
        template<typename Type> TypedVector3<Type>* Vector3CrossProduct(TypedVector3<Type>* result, const TypedVector3<Type>* leftSide,
            const TypedVector3<Type>* rightSide);
 
        template<typename Type> TypedVector2<Type>* Vector2Normalize(TypedVector2<Type>* result, const TypedVector2<Type>* value);
        template<typename Type> TypedVector3<Type>* Vector3Normalize(TypedVector3<Type>* result, const TypedVector3<Type>* value);
        template<typename Type> TypedVector4<Type>* Vector4Normalize(TypedVector4<Type>* result, const TypedVector4<Type>* value);
 
        template<typename Type> TypedVector2<Type>* Vector2NormalizeMagnitude(TypedVector2<Type>* result, const TypedVector2<Type>* value, Type& magnitude);
        template<typename Type> TypedVector3<Type>* Vector3NormalizeMagnitude(TypedVector3<Type>* result, const TypedVector3<Type>* value, Type& magnitude);
        template<typename Type> TypedVector4<Type>* Vector4NormalizeMagnitude(TypedVector4<Type>* result, const TypedVector4<Type>* value, Type& magnitude);
 
        enum SkipInitialization { kSkipInitialization = 0, };
 
        enum VectorComponent
        {
            kComponentX = 0, 
            kComponentY,     
            kComponentZ,     
            kComponentW      
        };
 
        template<typename Type> class TypedVector2
        {
        public:
            static TypedVector2 Zero(void) { return TypedVector2(Type(0), Type(0)); }
 
            static TypedVector2 One(void) { return TypedVector2(Type(1), Type(1)); }
 
            static TypedVector2 Right(void) { return TypedVector2(Type(1), Type(0)); }
            static TypedVector2 Left(void) { return -Right(); }
            static TypedVector2 Up(void) { return TypedVector2(Type(0), Type(1)); }
            static TypedVector2 Down(void) { return -Up(); }
 
            union
            {
                Type mComponents[2];
 
#if defined(tb_visual_cpp)
#pragma warning(push)
#pragma warning(disable: 4201)
                struct { Type x, y; };
#pragma warning(pop)
#else
                struct { Type x, y; };
#endif
            };
 
            inline explicit TypedVector2(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }
 
            inline TypedVector2(void) :
                x(Type(0)),
                y(Type(0))
            {
            }
 
            inline TypedVector2(const Type valueX, const Type valueY) :
                x(valueX),
                y(valueY)
            {
            }
 
            inline explicit TypedVector2(const Type* componentArray) :
                x(componentArray[0]),
                y(componentArray[1])
            {
            }
 
            inline TypedVector2(const TypedVector2& other) :
                x(other.x),
                y(other.y)
            {
            }
 
 
            template<typename FromType> explicit TypedVector2(const TypedVector2<FromType>& other) :
                x(static_cast<Type>(other.x)),
                y(static_cast<Type>(other.y))
            {
            }
 
 
            inline ~TypedVector2(void)
            {
            }
 
            inline TypedVector2& operator=(const TypedVector2& other)
            {
                x = other.x;
                y = other.y;
                return *this;
            }
 
            inline bool operator==(const TypedVector2& other) const
            {
                return (true == IsEqual(x, other.x) && true == IsEqual(y, other.y)) ? true : false;
            }
 
            inline bool operator!=(const TypedVector2& other) const
            {
                return (true == operator==(other)) ? false : true;
            }
 
            inline explicit operator const Type* (void) const { return mComponents; }
 
            inline explicit operator Type* (void) { return mComponents; }
 
            template<typename ToType> explicit operator TypedVector2<ToType>(void) const
            {
                return TypedVector2<ToType>(static_cast<ToType>(x), static_cast<ToType>(y));
            }
 
            inline const Type& operator[](const int index) const { return mComponents[index]; }
            inline const Type& operator[](const std::size_t& index) const { return mComponents[index]; }
 
            inline Type& operator[](const int index) { return mComponents[index]; }
            inline Type& operator[](const std::size_t& index) { return mComponents[index]; }
 
            static inline Type Dot(const TypedVector2<Type>& leftSide, const TypedVector2<Type>& rightSide)
            {
                return Vector2DotProduct(&leftSide, &rightSide);
            }
 
            static inline TypedVector2 Normalize(const TypedVector2<Type>& value)
            {
                TypedVector2<Type> result(kSkipInitialization);
                Vector2Normalize(&result, &value);
                return result;
            }
 
            static inline TypedVector2 Normalize(const TypedVector2<Type>& value, Type& magnitude)
            {
                TypedVector2<Type> result(kSkipInitialization);
                Vector2NormalizeMagnitude(&result, &value, magnitude);
                return result;
            }
 
#if defined(tb_with_math_operators)
            inline TypedVector2 operator+(const TypedVector2& rightSide) const { return TypedVector2(x + rightSide.x, y + rightSide.y); }
 
            inline TypedVector2& operator+=(const TypedVector2& rightSide) { x += rightSide.x; y += rightSide.y;    return *this; }
 
            inline TypedVector2 operator-(const TypedVector2& rightSide) const { return TypedVector2(x - rightSide.x, y - rightSide.y); }
 
            inline TypedVector2& operator-=(const TypedVector2& rightSide) { x -= rightSide.x; y -= rightSide.y;    return *this; }
 
            inline TypedVector2 operator*(Type scalar) const { return TypedVector2(x * scalar, y * scalar); }
 
            friend TypedVector2 operator*(Type scalar, const TypedVector2& rightSide) { return TypedVector2(scalar * rightSide.x, scalar * rightSide.y); }
 
            inline TypedVector2& operator*=(Type scalar) { x *= scalar; y *= scalar;    return *this; }
 
            inline TypedVector2 operator/(Type scalar) const { return TypedVector2(x / scalar, y / scalar); }
 
            inline TypedVector2& operator/=(Type scalar) { x /= scalar; y /= scalar;    return *this; }
 
            friend TypedVector2 operator/(Type scalar, const TypedVector2& rightSide) { return TypedVector2(scalar / rightSide.x, scalar / rightSide.y); }
 
            inline TypedVector2 operator-(void) const { return TypedVector2(-x, -y); }
 
            inline Type operator*(const TypedVector2& rhs) const { return (x * rhs.x) + (y * rhs.y); }
 
            inline Type Magnitude(void) const { return sqrt((x * x) + (y * y)); }
 
            inline Type MagnitudeSquared(void) const { return (x * x) + (y * y); }
 
            inline TypedVector2 GetNormalized(void) const
            {
                const Type magnitude(Magnitude());
                if (true == IsZero(magnitude)) { return Zero(); }
                return TypedVector2(x / magnitude, y / magnitude);
            }
 
            inline Type Normalize(void)
            {
                const Type magnitude(Magnitude());
                if (false == IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                }
                return magnitude;
            }
 
            inline void Scale(Type scalar) { *this *= scalar; }
 
            inline void SetLength(Type length) { Normalize(); *this *= length; }
 
            inline TypedAngle<Type> AngleTo(const TypedVector2& other) const
            {
                const Type productOfMagnitudes(Magnitude() * other.Magnitude());
                if (true == IsZero(productOfMagnitudes)) { return TypedAngle<Type>::Radians(Type(0.0)); }
                const Type value(Dot(*this, other) / productOfMagnitudes);
                const Type clampedValue((value < Type(-1.0)) ? Type(-1.0) : (value > Type(1.0)) ? Type(1.0) : value); //Clamp: -1.0f <= value <= 1.0f
                return TypedAngle<Type>::Radians(acos(clampedValue));
            }
 
            inline TypedVector2<Type> DirectionTo(const TypedVector2& other) const
            {
                return (other - *this).GetNormalized();
            }
 
            inline Type DistanceTo(const TypedVector2& other) const
            {
                return (other - *this).Magnitude();
            }
 
            inline Type SquaredDistanceTo(const TypedVector2& other) const
            {
                return (other - *this).MagnitudeSquared();
            }
 
 
#endif /* tb_with_math_operators */
        };
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
        template<typename Type> class TypedVector3
        {
        public:
            static TypedVector3 Zero(void) { return TypedVector3(Type(0), Type(0), Type(0)); }
 
            static TypedVector3 One(void) { return TypedVector3(Type(1), Type(1), Type(1)); }
 
            static TypedVector3 Right(void) { return TypedVector3(Type(1), Type(0), Type(0)); }
            static TypedVector3 Left(void) { return -Right(); }
            static TypedVector3 Up(void) { return TypedVector3(Type(0), Type(1), Type(0)); }
            static TypedVector3 Down(void) { return -Up(); }
#if defined(tb_righthanded_math)
            static TypedVector3 Forward(void) { return TypedVector3(Type(0), Type(0), Type(-1)); }
#else
            static TypedVector3 Forward(void) { return TypedVector3(Type(0), Type(0), Type(1)); }
#endif
            static TypedVector3 Backward(void) { return -Forward(); }
 
            union
            {
                Type mComponents[3];
 
#if defined(tb_visual_cpp)
#pragma warning(push)
#pragma warning(disable: 4201)
                struct { Type x, y, z; };
#pragma warning(pop)
#else
                struct { Type x, y, z; };
#endif
            };
 
            inline explicit TypedVector3(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }
 
            inline TypedVector3(void) :
                x(Type(0)),
                y(Type(0)),
                z(Type(0))
            {
            }
 
            inline TypedVector3(const Type valueX, const Type valueY, const Type valueZ) :
                x(valueX),
                y(valueY),
                z(valueZ)
            {
            }
 
            inline explicit TypedVector3(const TypedVector2<Type>& other, const Type valueZ) :
                x(other.x),
                y(other.y),
                z(valueZ)
            {
            }
 
            inline explicit TypedVector3(const Type* componentArray) :
                x(componentArray[0]),
                y(componentArray[1]),
                z(componentArray[2])
            {
            }
 
            TypedVector3(const TypedVector3<Type>& other) :
                x(other.x),
                y(other.y),
                z(other.z)
            {
            }
 
            template<typename FromType> explicit TypedVector3(const TypedVector3<FromType>& other) :
                x(static_cast<Type>(other.x)),
                y(static_cast<Type>(other.y)),
                z(static_cast<Type>(other.z))
            {
            }
 
            ~TypedVector3(void)
            {
            }
 
            inline TypedVector3& operator=(const TypedVector3& other)
            {
                x = other.x;
                y = other.y;
                z = other.z;
                return *this;
            }
 
            //
            // TODO: TIM: Planning: Would this be useful to have, or just dangerous?
            //
            //inline TypedVector3& operator=(const TypedVector2 &v)
            //{
            //  x = v.x;    y = v.y; /* z = z; */
            //  return (*this);
            //}
 
            inline bool operator==(const TypedVector3& other) const
            {
                return (true == tbMath::IsEqual(x, other.x) && true == tbMath::IsEqual(y, other.y) && true == tbMath::IsEqual(z, other.z)) ? true : false;
            }
 
            inline bool operator!=(const TypedVector3& other) const
            {
                return (true == operator==(other)) ? false : true;
            }
 
            inline explicit operator const Type* (void) const { return mComponents; }
 
            inline explicit operator Type* (void) { return mComponents; }
 
            template<typename ToType> operator TypedVector3<ToType>(void) const
            {
                return TypedVector3<ToType>(static_cast<ToType>(x), static_cast<ToType>(y), static_cast<ToType>(z));
            }
 
            inline const Type& operator[](const int index) const { return mComponents[index]; }
            inline const Type& operator[](const std::size_t& index) const { return mComponents[index]; }
 
            inline Type& operator[](const int index) { return mComponents[index]; }
            inline Type& operator[](const std::size_t& index) { return mComponents[index]; }
 
            static inline Type Dot(const TypedVector3<Type>& leftSide, const TypedVector3<Type>& rightSide)
            {
                return Vector3DotProduct(&leftSide, &rightSide);
            }
 
            static inline TypedVector3 Cross(const TypedVector3<Type>& leftSide, const TypedVector3<Type>& rightSide)
            {
                TypedVector3<Type> result(kSkipInitialization);
                Vector3CrossProduct(&result, &leftSide, &rightSide);
                return result;
            }
 
            static inline TypedVector3 Normalize(const TypedVector3<Type>& value)
            {
                TypedVector3<Type> result(kSkipInitialization);
                Vector3Normalize(&result, &value);
                return result;
            }
 
            static inline TypedVector3 Normalize(const TypedVector3<Type>& value, Type& magnitude)
            {
                TypedVector3<Type> result(kSkipInitialization);
                Vector3NormalizeMagnitude(&result, &value, magnitude);
                return result;
            }
 
#if defined(tb_with_math_operators)
            inline TypedVector3<Type> operator+(const TypedVector3<Type>& rightSide) const
            {
                return TypedVector3<Type>(x + rightSide.x, y + rightSide.y, z + rightSide.z);
            }
 
            inline TypedVector3& operator+=(const TypedVector3& rightSide) { x += rightSide.x; y += rightSide.y;    z += rightSide.z;   return *this; }
 
            inline TypedVector3 operator-(const TypedVector3& rightSide) const { return TypedVector3(x - rightSide.x, y - rightSide.y, z - rightSide.z); }
 
            inline TypedVector3& operator-=(const TypedVector3& rightSide) { x -= rightSide.x; y -= rightSide.y;    z -= rightSide.z;   return *this; }
 
 
            inline TypedVector3 operator*(Type scalar) const { return TypedVector3(x * scalar, y * scalar, z * scalar); }
 
            friend TypedVector3 operator*(Type scalar, const TypedVector3& rightSide) { return TypedVector3(scalar * rightSide.x, scalar * rightSide.y, scalar * rightSide.z); }
 
            inline TypedVector3& operator*=(Type scalar) { x *= scalar; y *= scalar;    z *= scalar;    return *this; }
 
            inline TypedVector3 operator/(Type scalar) const { return TypedVector3(x / scalar, y / scalar, z / scalar); }
 
            inline TypedVector3& operator/=(Type scalar) { x /= scalar; y /= scalar;    z /= scalar;    return *this; }
 
            friend TypedVector3 operator/(Type scalar, const TypedVector3& rightSide) { return TypedVector3(scalar / rightSide.x, scalar / rightSide.y, scalar / rightSide.z); }
 
            inline TypedVector3 operator-(void) const { return TypedVector3(-x, -y, -z); }
 
            inline Type operator*(const TypedVector3& rhs) const { return (x * rhs.x) + (y * rhs.y) + (z * rhs.z); }
 
            inline TypedVector3 operator^(const TypedVector3& rightSide) const
            {
                return TypedVector3((y * rightSide.z) - (rightSide.y * z), -((x * rightSide.z) - (rightSide.x * z)), (x * rightSide.y) - (rightSide.x * y));
            }
 
 
            inline Type Magnitude(void) const { return sqrt((x * x) + (y * y) + (z * z)); }
 
            inline Type MagnitudeSquared(void) const { return (x * x) + (y * y) + (z * z); }
 
            inline TypedVector3 GetNormalized(void) const
            {
                const Type magnitude(Magnitude());
                if (true == tbMath::IsZero(magnitude)) { return Zero(); }
                return TypedVector3(x / magnitude, y / magnitude, z / magnitude);
            }
 
            inline TypedVector3 GetNormalized(Type& magnitude) const
            {
                magnitude = (Magnitude());
                if (true == tbMath::IsZero(magnitude)) { return Zero(); }
                return TypedVector3(x / magnitude, y / magnitude, z / magnitude);
            }
 
            inline Type Normalize(void)
            {
                const Type magnitude(Magnitude());
                if (false == tbMath::IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                    z /= magnitude;
                }
                return magnitude;
            }
 
            inline void Scale(Type scalar) { *this *= scalar; }
 
            inline void SetLength(const Type length) { Normalize(); *this *= length; }
 
            inline TypedAngle<Type> AngleTo(const TypedVector3& other) const
            {
                const Type productOfMagnitudes(Magnitude() * other.Magnitude());
                if (true == IsZero(productOfMagnitudes)) { return TypedAngle<Type>::Radians(Type(0.0)); }
                const Type value(Dot(*this, other) / productOfMagnitudes);
                const Type clampedValue((value < Type(-1.0)) ? Type(-1.0) : (value > Type(1.0)) ? Type(1.0) : value); //Clamp: -1.0f <= value <= 1.0f
                return TypedAngle<Type>::Radians(acos(clampedValue));
 
                // 2024-03-22: Godot 4.2.1 implementation of Vector3::angle_to, differed a bit, tested to see if the
                //   SnailedIt! snail could roll on walls. It currently detects walls good for crawling, just not rolling.
                //return TypedAngle<Type>::Radians(std::atan2(Cross(*this, other).Magnitude(), Dot(*this, other)));
            }
 
            inline TypedVector3<Type> DirectionTo(const TypedVector3& other) const
            {
                return (other - *this).GetNormalized();
            }
 
            inline Type DistanceTo(const TypedVector3& other) const
            {
                return (other - *this).Magnitude();
            }
 
            inline Type SquaredDistanceTo(const TypedVector3& other) const
            {
                return (other - *this).MagnitudeSquared();
            }
 
#endif /* tb_with_math_operators */
    };
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
        template<typename Type> class TypedVector4
        {
        public:
            static TypedVector4 Zero(void) { return TypedVector4(Type(0), Type(0), Type(0), Type(0)); }
 
            static TypedVector4 One(void) { return TypedVector4(Type(1), Type(1), Type(1), Type(1)); }
 
            union
            {
                Type mComponents[4];
 
#if defined(tb_visual_cpp)
#pragma warning(push)
#pragma warning(disable: 4201)
                struct { Type x, y, z, w; };
#pragma warning(pop)
#else
                struct { Type x, y, z, w; };
#endif
            };
 
            inline explicit TypedVector4(const SkipInitialization& fastAndStupid)
            {
                tb_unused(fastAndStupid);
            }
 
            inline TypedVector4(void) :
                x(Type(0)),
                y(Type(0)),
                z(Type(0)),
                w(Type(0))
            {
            }
 
            inline TypedVector4(const Type valueX, const Type valueY, const Type valueZ, const Type valueW) :
                x(valueX),
                y(valueY),
                z(valueZ),
                w(valueW)
            {
            }
 
            inline explicit TypedVector4(const TypedVector2<Type>& other, const Type valueZ, const Type valueW) :
                x(other.x),
                y(other.y),
                z(valueZ),
                w(valueW)
            {
            }
 
            inline explicit TypedVector4(const TypedVector3<Type>& other, const Type valueW) :
                x(other.x),
                y(other.y),
                z(other.z),
                w(valueW)
            {
            }
 
            inline explicit TypedVector4(const Type* componentArray) :
                x(componentArray[0]),
                y(componentArray[1]),
                z(componentArray[2]),
                w(componentArray[3])
            {
            }
 
            inline TypedVector4(const TypedVector4& other) :
                x(other.x),
                y(other.y),
                z(other.z),
                w(other.w)
            {
            }
 
            template<typename FromType> explicit TypedVector4(const TypedVector4<FromType>& other) :
                x(static_cast<Type>(other.x)),
                y(static_cast<Type>(other.y)),
                z(static_cast<Type>(other.z)),
                w(static_cast<Type>(other.w))
            {
            }
 
            ~TypedVector4(void)
            {
            }
 
            inline TypedVector4& operator=(const TypedVector4& other)
            {
                x = other.x;
                y = other.y;
                z = other.z;
                w = other.w;
                return *this;
            }
 
            inline bool operator==(const TypedVector4& 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 TypedVector4& other) const
            {
                return (true == operator==(other)) ? false : true;
            }
 
            inline explicit operator const Type* (void) const { return mComponents; }
 
            inline explicit operator Type* (void) { return mComponents; }
 
            template<typename ToType> explicit operator TypedVector4<ToType>(void) const
            {
                return TypedVector4<ToType>(static_cast<ToType>(x), static_cast<ToType>(y), static_cast<ToType>(z), static_cast<ToType>(w));
            }
 
            inline const Type& operator[](const int index) const { return mComponents[index]; }
            inline const Type& operator[](const std::size_t& index) const { return mComponents[index]; }
 
            inline Type& operator[](const int index) { return mComponents[index]; }
            inline Type& operator[](const std::size_t& index) { return mComponents[index]; }
 
            static inline Type Dot(const TypedVector4<Type>& leftSide, const TypedVector4<Type>& rightSide)
            {
                return Vector4DotProduct(&leftSide, &rightSide);
            }
 
            static inline TypedVector4 Cross(const TypedVector4<Type>& leftSide, const TypedVector4<Type>& rightSide)
            {
                TypedVector4<Type> result(kSkipInitialization);
                Vector4CrossProduct(&result, &leftSide, &rightSide);
                return result;
            }
 
            static inline TypedVector4 Normalize(const TypedVector4<Type>& value)
            {
                TypedVector4<Type> result(kSkipInitialization);
                Vector4Normalize(&result, &value);
                return result;
            }
 
            static inline TypedVector4 Normalize(const TypedVector4<Type>& value, Type& magnitude)
            {
                TypedVector4<Type> result(kSkipInitialization);
                Vector4NormalizeMagnitude(&result, &value, magnitude);
                return result;
            }
 
 
#if defined(tb_with_math_operators)
            inline TypedVector4 operator+(const TypedVector4& rightSide) const { return TypedVector4(x + rightSide.x, y + rightSide.y, z + rightSide.z, w + rightSide.w); }
 
            inline TypedVector4& operator+=(const TypedVector4& rightSide) { x += rightSide.x; y += rightSide.y; z += rightSide.z; w += rightSide.w; return *this; }
 
            inline TypedVector4 operator-(const TypedVector4& rightSide) const { return TypedVector4(x - rightSide.x, y - rightSide.y, z - rightSide.z, w - rightSide.w); }
 
            inline TypedVector4& operator-=(const TypedVector4& rightSide) { x -= rightSide.x; y -= rightSide.y;    z -= rightSide.z; w -= rightSide.w; return *this; }
 
 
            inline TypedVector4 operator*(Type scalar) const { return TypedVector4(x * scalar, y * scalar, z * scalar, w * scalar); }
 
            friend TypedVector4 operator*(Type scalar, const TypedVector4& rightSide) { return TypedVector4(scalar * rightSide.x, scalar * rightSide.y, scalar * rightSide.z, scalar * rightSide.w); }
 
            inline TypedVector4& operator*=(Type scalar) { x *= scalar; y *= scalar;    z *= scalar; w *= scalar;   return *this; }
 
            inline TypedVector4 operator/(Type scalar) const { return TypedVector4(x / scalar, y / scalar, z / scalar, w / scalar); }
 
            inline TypedVector4& operator/=(Type scalar) { x /= scalar; y /= scalar;    z /= scalar; w /= scalar;   return *this; }
 
            friend TypedVector4 operator/(Type scalar, const TypedVector4& rightSide) { return TypedVector4(scalar / rightSide.x, scalar / rightSide.y, scalar / rightSide.z, scalar / rightSide.w); }
 
            inline TypedVector4 operator-(void) const { return TypedVector4(-x, -y, -z, -w); }
 
            inline Type operator*(const TypedVector4& 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 TypedVector4 operator^(const TypedVector4 &rhs) const  {   return TypedVector4((y * rhs.z) - (rhs.y * z), -((x * rhs.z) - (rhs.x * z)), (x * rhs.y) - (rhs.x * y));     }
 
            inline Type Magnitude(void) const { return sqrt((x * x) + (y * y) + (z * z) + (w * w)); }
 
            inline Type MagnitudeSquared(void) const { return (x * x) + (y * y) + (z * z) + (w * w); }
 
            inline TypedVector4 GetNormalized(void) const
            {
                const Type magnitude(Magnitude());
                if (true == IsZero(magnitude)) { return Zero(); }
                return TypedVector4(x / magnitude, y / magnitude, z / magnitude, w / magnitude);
            }
 
            inline Type Normalize(void)
            {
                const Type magnitude(Magnitude());
                if (false == IsZero(magnitude))
                {
                    x /= magnitude;
                    y /= magnitude;
                    z /= magnitude;
                    w /= magnitude;
                }
                return magnitude;
            }
 
            inline void Scale(Type scalar) { *this *= scalar; }
 
            inline void SetLength(Type length) { Normalize(); *this *= length; }
 
            inline TypedAngle<Type> AngleTo(const TypedVector4& other) const
            {
                const Type productOfMagnitudes(Magnitude() * other.Magnitude());
                if (true == IsZero(productOfMagnitudes)) { return TypedAngle<Type>::Radians(Type(0.0)); }
                const Type value(Dot(*this, other) / productOfMagnitudes);
                const Type clampedValue((value < Type(-1.0)) ? Type(-1.0) : (value > Type(1.0)) ? Type(1.0) : value); //Clamp: -1.0f <= value <= 1.0f
                return TypedAngle<Type>::Radians(acos(clampedValue));
            }
 
            inline TypedVector4<Type> DirectionTo(const TypedVector4& other) const
            {
                return (other - *this).GetNormalized();
            }
 
            inline Type DistanceTo(const TypedVector4& other) const
            {
                return (other - *this).Magnitude();
            }
 
            inline Type SquaredDistanceTo(const TypedVector4& other) const
            {
                return (other - *this).MagnitudeSquared();
            }
#endif /* tb_with_math_operators */
        };
 
        typedef TypedVector2<float> Vector2;
        typedef TypedVector3<float> Vector3;
        typedef TypedVector4<float> Vector4;
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
        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;
        }
 
        template<typename Type> Type Vector2DotProduct(const TypedVector2<Type>* leftSide, const TypedVector2<Type>* 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);
        }
 
        template<typename Type> Type Vector3DotProduct(const TypedVector3<Type>* leftSide, const TypedVector3<Type>* 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);
        }
 
        template<typename Type> Type Vector4DotProduct(const TypedVector4<Type>* leftSide, const TypedVector4<Type>* 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);
        }
 
        template<typename Type> TypedVector3<Type>* Vector3CrossProduct(TypedVector3<Type>* result,
            const TypedVector3<Type>* leftSide, const TypedVector3<Type>* 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;
        }
 
        //Possible future API stuff, for easier usage?
        //inline Vector3 Vector3CrossProduct(const Vector3& leftSide, const Vector3& rightSide)
        //{
        //  Vector3 result(kSkipInitialization);
        //  Vector3CrossProduct(&result, &leftSide, &rightSide);
        //  return result;
        //}
 
        template<typename Type> Type Vector2Magnitude(const TypedVector2<Type>* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return sqrt((input->x * input->x) + (input->y * input->y));
        }
 
        template<typename Type> Type Vector3Magnitude(const TypedVector3<Type>* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return std::sqrt((input->x * input->x) + (input->y * input->y) + (input->z * input->z));
        }
 
        template<typename Type> Type Vector4Magnitude(const TypedVector4<Type>* 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));
        }
 
        template<typename Type> Type Vector2MagnitudeSquared(const TypedVector2<Type>* input)
        {
            tb_error_if(nullptr == input, "tbExternalError: Invalid parameter for input, expected valid pointer.");
            return (input->x * input->x) + (input->y * input->y);
        }
 
        template<typename Type> Type Vector3MagnitudeSquared(const TypedVector3<Type>* 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);
        }
 
        template<typename Type> Type Vector4MagnitudeSquared(const TypedVector4<Type>* 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);
        }
 
        template<typename Type> TypedVector2<Type>* Vector2Normalize(TypedVector2<Type>* result, const TypedVector2<Type>* 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.");
 
            const Type magnitude = Vector2Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedVector3<Type>* Vector3Normalize(TypedVector3<Type>* result, const TypedVector3<Type>* 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.");
 
            const Type magnitude = Vector3Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
                result->z = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedVector4<Type>* Vector4Normalize(TypedVector4<Type>* result, const TypedVector4<Type>* 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.");
 
            const Type magnitude = Vector4Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
                result->z = Type(0);
                result->w = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
                result->w = input->w / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedVector2<Type>* Vector2NormalizeMagnitude(TypedVector2<Type>* result,
            const TypedVector2<Type>* input, Type& magnitude)
        {
            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.");
 
            magnitude = Vector2Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedVector3<Type>* Vector3NormalizeMagnitude(TypedVector3<Type>* result,
            const TypedVector3<Type>* input, Type &magnitude)
        {
            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.");
 
            magnitude = Vector3Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
                result->z = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedVector4<Type>* Vector4NormalizeMagnitude(TypedVector4<Type>* result,
            const TypedVector4<Type>* input, Type &magnitude)
        {
            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.");
 
            magnitude = Vector4Magnitude(input);
            if (true == IsZero(magnitude))
            {
                result->x = Type(0);
                result->y = Type(0);
                result->z = Type(0);
                result->w = Type(0);
            }
            else
            {
                result->x = input->x / magnitude;
                result->y = input->y / magnitude;
                result->z = input->z / magnitude;
                result->w = input->w / magnitude;
            }
            return result;
        }
 
        template<typename Type> TypedAngle<Type> Vector3AngleBetween(const TypedVector3<Type>* left, const TypedVector3<Type>* right)
        {
            const Type productOfMagnitudes(Vector3Magnitude(left) * Vector3Magnitude(right));
            if (true == IsZero(productOfMagnitudes)) { return TypedAngle<Type>::Radians(Type(0)); }
            const Type value(Vector3DotProduct(left, right) / productOfMagnitudes);
            const Type clampedValue((value < Type(-1)) ? Type(-1) : (value > Type(1)) ? Type(1)  : value); //Clamp: -1.0f <= value <= 1.0f
            return TypedAngle<Type>::Radians(acos(clampedValue));
        }
 
        static inline Vector3& RotationXZToForwardVector3(Vector3& result, const Angle& orientation)
        {
            result.x = sin(orientation.AsRadians());
            result.y = 0.0f;
            result.z = -cos(orientation.AsRadians());
            return result;
        }
 
        static inline Vector2& RotationToForwardVector2(Vector2& result, const Angle& orientation)
        {
            result.x = sin(orientation.AsRadians());
            result.y = -cos(orientation.AsRadians());
            return result;
        }
 
        static inline Angle ForwardVector3ToRotationXZ(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 Angle::Radians(orientation);
        }
 
        static inline Angle ForwardVector2ToRotation(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 Angle::Radians(orientation);
        }
 
 
        template<typename Type> std::ostream& operator<<(std::ostream& output, const tbMath::TypedVector2<Type>& data)
        {
            output << "{ " << data.x << ", " << data.y << " }";
            return output;
        }
 
        template<typename Type> std::istream& operator>>(std::istream& input, const tbMath::TypedVector2<Type>& data)
        {
            String token;
            input >> token; // {
            input >> token; data.x = tbCore::FromString<Type>(token);
            input >> token; data.y = tbCore::FromString<Type>(token);
            input >> token; // }
            return input;
        }
 
        template<typename Type> std::ostream& operator<<(std::ostream& output, const tbMath::TypedVector3<Type>& data)
        {
            output << "{ " << data.x << ", " << data.y << ", " << data.z << " }";
            return output;
        }
 
        template<typename Type> std::istream& operator>>(std::istream& input, const tbMath::TypedVector3<Type>& data)
        {
            String token;
            input >> token; // {
            input >> token; data.x = tbCore::FromString<Type>(token);
            input >> token; data.y = tbCore::FromString<Type>(token);
            input >> token; data.z = tbCore::FromString<Type>(token);
            input >> token; // }
            return input;
        }
 
        template<typename Type> std::ostream& operator<<(std::ostream& output, const tbMath::TypedVector4<Type>& data)
        {
            output << "{ " << data.x << ", " << data.y << ", " << data.z << ", " << data.w << " }";
            return output;
        }
 
        template<typename Type> std::istream& operator>>(std::istream& input, const tbMath::TypedVector4<Type>& data)
        {
            String token;
            input >> token; // {
            input >> token; data.x = tbCore::FromString<Type>(token);
            input >> token; data.y = tbCore::FromString<Type>(token);
            input >> token; data.z = tbCore::FromString<Type>(token);
            input >> token; data.w = tbCore::FromString<Type>(token);
            input >> token; // }
            return input;
        }
 
 
        //typedef TypedVector2<float> Vector2;
        //typedef TypedVector3<float> Vector3;
        //typedef TypedVector4<float> Vector4;
 
    }; /* namespace Math */
}; /* namespace TurtleBrains */
 
namespace tbMath = TurtleBrains::Math;
 
namespace TurtleBrains
{
    using Vector2 = TurtleBrains::Math::Vector2;
    using Vector3 = TurtleBrains::Math::Vector3;
    using Vector4 = TurtleBrains::Math::Vector4;
};
 
#endif /* TurtleBrains_Vector_hpp */