Vector2.hpp

#pragma once
#ifndef __H__OCULAR_MATH_VECTOR_2__H__
#define __H__OCULAR_MATH_VECTOR_2__H__

#include "MathCommon.hpp"
#include "Equality.hpp"
#include "Utilities/Types.hpp"
#include "Exceptions/Exception.hpp"

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

namespace Ocular
{
    namespace Math
    {
        template<typename T>
        class Vector2
        {
        public:

            Vector2(T const* values)
            {
                x = values[0];
                y = values[1];
            }

            Vector2(T const &pX, T const &pY)
            {
                x = pX;
                y = pY;
            }

            Vector2()
            {
                x = static_cast<T>(0);
                y = static_cast<T>(0);
            }

            ~Vector2()
            {

            }

            //------------------------------------------------------------------------------
            // OPERATORS
            //------------------------------------------------------------------------------

            T& operator[](unsigned const& index)
            {
                switch(index)
                {
                case 0:
                    return x;
                    
                case 1:
                    return y;

                default:
                    THROW_EXCEPTION("Out-Of-Bounds Vector Access");
                    return x;
                }
            }

            T operator[](unsigned const& index) const
            {
                switch(index)
                {
                case 0:
                    return x;
                    
                case 1:
                    return y;

                default:
                    THROW_EXCEPTION("Out-Of-Bounds Vector Access");
                    return x;
                }
            }
            
            Vector2<T> operator-()
            {
                return Vector2<T>(-x, -y);
            }

            Vector2<T>& operator=(Vector2<T> const &rhs)
            {
                x = rhs.x;
                y = rhs.y;

                return *this;
            }

            Vector2<T>& operator+=(Vector2<T> const &rhs)
            {
                x += rhs.x;
                y += rhs.y;

                return *this;
            }

            Vector2<T>& operator+=(T const &rhs)
            {
                x += rhs;
                y += rhs;

                return *this;
            }

            Vector2<T>& operator-=(Vector2<T> const &rhs)
            {
                x -= rhs.x;
                y -= rhs.y;

                return *this;
            }

            Vector2<T>& operator-=(T const &rhs)
            {
                x -= rhs;
                y -= rhs;

                return *this;
            }

            Vector2<T>& operator*=(Vector2<T> const &rhs)
            {
                x *= rhs.x;
                y *= rhs.y;

                return *this;
            }

            Vector2<T>& operator*=(T const &rhs)
            {
                x *= rhs;
                y *= rhs;

                return *this;
            }

            Vector2<T>& operator/=(Vector2<T> const &rhs)
            {
                x /= rhs.x;
                y /= rhs.y;

                return *this;
            }

            Vector2<T>& operator/=(T const &rhs)
            {
                x /= rhs;
                y /= rhs;

                return *this;
            }

            //------------------------------------------------------------------------------
            // OPERATIONS
            //------------------------------------------------------------------------------

            T getMagnitude() const
            {
                return std::sqrt((x * x) + (y * y));
            }

            T getLength() const
            {
                return getMagnitude();
            }

            void normalize()
            {
                // Normalization is simply multiplying the vector by the reciprocal of its magnitude. 

                double length = getMagnitude();

                if(IsEqual<T>(length, static_cast<T>(0)))
                {
                    x = static_cast<T>(0);
                    y = static_cast<T>(0);
                }
                else
                {
                    x /= static_cast<T>(length);
                    y /= static_cast<T>(length);
                }
            }

            Vector2<T> getNormalized() const
            {
                Vector2<T> result(x, y);
                result.normalize();

                return result;
            }

            T getDeterminant(Vector2<T> const& rhs)
            {
                return (x * rhs.y) - (rhs.x * y);
            }

            T dot(Vector2<T> const &rhs) const
            {
                return (x * rhs.x) + (y * rhs.y);
            }

            double angleBetween(Vector2<T> const &rhs) const
            {
                Vector2<T> normalLHS = getNormalized();
                Vector2<T> normalRHS = rhs.getNormalized();

                double angle = std::acos(normalLHS.dot(normalRHS));

                if(angle > PI)
                {
                    angle = PI_TWO - angle;
                }

                return angle;
            }

            double distanceTo(Vector2<T> const &rhs) const
            {
                Vector2<T> distance = (*this) - rhs;
                return distance.getMagnitude();
            }

            //------------------------------------------------------------------------------
            // VARIABLES
            //------------------------------------------------------------------------------

            union { T x, u, s; };
            union { T y, v, t; };

            static bool OCULAR_INTERNAL_Force;

        protected:

        private:
        };

        //----------------------------------------------------------------------------------
        
        template<typename T>
        bool operator==(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return IsEqual<T>(lhs.x, rhs.x) && IsEqual<T>(lhs.y, rhs.y);
        }
        
        template<typename T>
        bool operator!=(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return !(lhs == rhs);
        }

        template<typename T>
        Vector2<T> operator+(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return Vector2<T>(lhs.x + rhs.x, lhs.y + rhs.y);
        }

        template<typename T>
        Vector2<T> operator+(Vector2<T> const &lhs, T const rhs)
        {
            return Vector2<T>(lhs.x + rhs, lhs.y + rhs);
        }

        template<typename T>
        Vector2<T> operator-(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return Vector2<T>(lhs.x - rhs.x, lhs.y - rhs.y);
        }

        template<typename T>
        Vector2<T> operator-(Vector2<T> const &lhs, T const &rhs)
        {
            return Vector2<T>(lhs.x - rhs, lhs.y - rhs);
        }

        template<typename T>
        Vector2<T> operator*(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return Vector2<T>(lhs.x * rhs.x, lhs.y * rhs.y);
        }

        template<typename T>
        Vector2<T> operator*(Vector2<T> const &lhs, T const &rhs)
        {
            return Vector2<T>(lhs.x * rhs, lhs.y * rhs);
        }

        template<typename T>
        Vector2<T> operator/(Vector2<T> const &lhs, Vector2<T> const &rhs)
        {
            return Vector2<T>(lhs.x / rhs.x, lhs.y / rhs.y);
        }

        template<typename T>
        Vector2<T> operator/(Vector2<T> const &lhs, T const &rhs)
        {
            return Vector2<T>(lhs.x / rhs, lhs.y / rhs);
        }

        //--------------------------------------------
        // Common vector formats

        typedef Vector2<int32_t>  Vector2i;
        typedef Vector2<uint32_t> Vector2ui;
        typedef Vector2<float>    Vector2f;
        typedef Vector2<double>   Vector2d;

        typedef Vector2f Point2f;
        typedef Vector2d Point2d;

    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector2i,  "Vector2i");
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector2ui, "Vector2ui");
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector2f,  "Vector2f");
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector2d,  "Vector2d");

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

#endif