Vector3.hpp

#pragma once
#ifndef __H__OCULAR_MATH_VECTOR_3__H__
#define __H__OCULAR_MATH_VECTOR_3__H__

#include "Vector2.hpp"
#include "Euler.hpp"
#include "Equality.hpp"
#include "Utilities/Types.hpp"
#include "Exceptions/Exception.hpp"

#include <cmath>

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

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

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

            Vector3(Quaternion const& quat)
            {
                x = static_cast<T>(quat.getPitch());
                y = static_cast<T>(quat.getYaw());
                z = static_cast<T>(quat.getRoll());
            }

            Vector3(Euler const& euler)
            {
                x = static_cast<T>(euler.getPitch());
                y = static_cast<T>(euler.getYaw());
                z = static_cast<T>(euler.getRoll());
            }

            Vector3(Vector2<T> const& vec)
            {
                x = vec.x;
                y = vec.y;
                z = 0.0f;
            }

            Vector3(T const x, T const y, T const z)
            {
                this->x = x;
                this->y = y;
                this->z = z;
            }

            Vector3()
            {
                this->x = static_cast<T>(0);
                this->y = static_cast<T>(0);
                this->z = static_cast<T>(0);
            }

            ~Vector3()
            {

            }

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

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

                case 2:
                    return z;

                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;

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

            Vector3<T> operator-()
            {
                return Vector3<T>(-x, -y, -z);
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

                return *this;
            }

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

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

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

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

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

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

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

                return result;
            }

            Vector3<T> cross(Vector3<T> const& rhs) const
            {
                return Vector3<T>((y * rhs.z) - (z * rhs.y),
                    (z * rhs.x) - (x * rhs.z),
                    (x * rhs.y) - (y * rhs.x));
            }

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

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

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

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

                return angle;
            }

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

            static Vector3<T> Lerp(Vector3<T> const from, Vector3<T> const to, T fraction)
            {
                T zero = static_cast<T>(0);
                T one = static_cast<T>(1);

                // Adapted from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509618(v=vs.85).aspx
                fraction = Clamp<T>(fraction, zero, one);
                return (from * (one - fraction)) + (to * fraction);
            }

            static Vector3<T> Slerp(Vector3<T> const& from, Vector3<T> const& to, double fraction)
            {
                // Adapted from http://en.wikipedia.org/wiki/Slerp

                fraction = Clamp<double>(fraction, 0.0, 1.0);
                double omega = from.angleBetween(to);

                double lhs = std::sin((1.0 - fraction) * omega) / std::sin(omega);
                double rhs = std::sin(fraction * omega) / std::sin(omega);

                return (from * lhs) + (to * rhs);
            }

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

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

            //------------------------------------------------------------------------------
            // SPECIAL STATIC VECTORS
            //------------------------------------------------------------------------------

            // Ocular uses a right-handed coordinate system

            static Vector3<T> Identity() { return Vector3<T>(static_cast<T>( 0.0f), static_cast<T>( 0.0f), static_cast<T>( 0.0f)); }
            static Vector3<T> Up()       { return Vector3<T>(static_cast<T>( 0.0f), static_cast<T>( 1.0f), static_cast<T>( 0.0f)); }
            static Vector3<T> Down()     { return Vector3<T>(static_cast<T>( 0.0f), static_cast<T>(-1.0f), static_cast<T>( 0.0f)); }
            static Vector3<T> Left()     { return Vector3<T>(static_cast<T>(-1.0f), static_cast<T>( 0.0f), static_cast<T>( 0.0f)); }
            static Vector3<T> Right()    { return Vector3<T>(static_cast<T>( 1.0f), static_cast<T>( 0.0f), static_cast<T>( 0.0f)); }
            static Vector3<T> Forward()  { return Vector3<T>(static_cast<T>( 0.0f), static_cast<T>( 0.0f), static_cast<T>(-1.0f)); }
            static Vector3<T> Backward() { return Vector3<T>(static_cast<T>( 0.0f), static_cast<T>( 0.0f), static_cast<T>( 1.0f)); }

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

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

            static bool OCULAR_INTERNAL_Force;

        protected:

        private:
        };

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

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

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

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

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

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

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

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

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

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

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

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

        typedef Vector3<float> Vector3f;
        typedef Vector3<double> Vector3d;

        typedef Vector3f Point3f;
        typedef Vector3d Point3d;

    }
}
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector3f,  "Vector3f");
OCULAR_REGISTER_TYPE_CUSTOM(Ocular::Math::Vector3d,  "Vector3d");

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

#endif