Vector4.hpp

#pragma once
#ifndef __H__OCULAR_MATH_VECTOR_4__H__
#define __H__OCULAR_MATH_VECTOR_4__H__

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

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

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

            Vector4(T const* values)
            {
                x = values[0];
                y = values[1];
                z = values[2];
                w = values[3];
            }

            Vector4(Vector3<T> const& vec, T pW = static_cast<T>(1.0f))
            {
                x = vec.x;
                y = vec.y;
                z = vec.z;
                w = pW;
            }

            Vector4(T const &pX, T const &pY, T const &pZ, T const &pW)
            {
                x = pX;
                y = pY;
                z = pZ;
                w = pW;
            }

            Vector4()
            {
                x = static_cast<T>(0.0);
                y = static_cast<T>(0.0);
                z = static_cast<T>(0.0);
                w = static_cast<T>(1.0);
            }

            ~Vector4()
            {

            }

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

                case 2:
                    return z;

                case 3:
                    return w;

                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;

                case 2:
                    return z;

                case 3:
                    return w;

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

            Vector4<T>& operator=(Vector4<T> const &rhs)
            {
                x = rhs.x;
                y = rhs.y;
                z = rhs.z;
                w = rhs.w;

                return *this;
            }

            Vector4<T>& operator=(Vector3<T> const &rhs)
            {
                x = rhs.x;
                y = rhs.y;
                z = rhs.z;
                w = static_cast<T>(1);

                return *this;
            }

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

                return *this;
            }

            Vector4<T>& operator+=(T const &rhs)
            {
                x += rhs;
                y += rhs;
                z += rhs;
                w += rhs;

                return *this;
            }

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

                return *this;
            }

            Vector4<T>& operator-=(T const &rhs)
            {
                x -= rhs;
                y -= rhs;
                z -= rhs;
                w -= rhs;

                return *this;
            }

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

                return *this;
            }

            Vector4<T>& operator*=(T const &rhs)
            {
                x *= rhs;
                y *= rhs;
                z *= rhs;
                w *= rhs;

                return *this;
            }

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

                return *this;
            }

            Vector4<T>& operator/=(T const &rhs)
            {
                x /= rhs;
                y /= rhs;
                z /= rhs;
                w /= rhs;

                return *this;
            }

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

            Vector2<T> xy() const
            {
                return Vector2<T>(x, y);
            }

            Vector3<T> xyz() const
            {
                return Vector3<T>(x, y, z);
            }

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

            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);
                    z = static_cast<T>(0);
                    w = static_cast<T>(1);
                }
                else
                {
                    x /= static_cast<T>(length);
                    y /= static_cast<T>(length);
                    z /= static_cast<T>(length);
                    w /= static_cast<T>(length);
                }
            }

            Vector4<T> getNormalized() const
            {
                Vector4<T> result(x, y, z, w);
                result.normalize();

                return result;
            }

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

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

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

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

                return static_cast<T>(angle);
            }

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

            void homogenize()
            {
                x /= w;
                y /= w;
                z /= w;
                w /= w;
            }

            static Vector4<T> Midpoint(Vector4<T> const& a, Vector4<T> const& b)
            {
                T two = static_cast<T>(2);

                return Vector4<T>(
                    ((a.x + b.x) / two),
                    ((a.y + b.y) / two),
                    ((a.z + b.z) / two),
                    ((a.w + b.w) / two));
            }

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

            union { T x, r, u, s; };
            union { T y, g, v, t; };
            union { T z, b, p; };
            union { T w, a, q; };

            static bool OCULAR_INTERNAL_Force;

        protected:

        private:
        };

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

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

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

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

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

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

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

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

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

        typedef Vector4<float>  Vector4f;
        typedef Vector4<double> Vector4d;

        typedef Vector4f Point4f;
        typedef Vector4d Point4d;
    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector4f,  "Vector4f");
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector4d,  "Vector4d");

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

#endif