Vector2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Vector2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 2-D vector class.
> Created Time: 2017/02/19
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_VECTOR2_H
#define CUBBYFLOW_VECTOR2_H

#include <Core/Utils/Constants.h>
#include <Core/Utils/TypeHelpers.h>
#include <Core/Vector/Vector.h>

namespace CubbyFlow
{
    template <typename T>
    class Vector<T, 2> final
    {
    public:
        static_assert(std::is_floating_point<T>::value, "Vector only can be instantiated with floating point types");

        T x;

        T y;

        // MARK: Constructors
        constexpr Vector() : x(0), y(0)
        {
            // Do nothing
        }

        constexpr Vector(T _x, T _y) : x(_x), y(_y)
        {
            // Do nothing
        }

        template <typename U>
        Vector(const std::initializer_list<U>& list);

        constexpr Vector(const Vector& v) : x(v.x), y(v.y)
        {
            // Do nothing   
        }

        // MARK: Basic setters
        void Set(T s);

        void Set(T x, T y);

        template <typename U>
        void Set(const std::initializer_list<U>& list);

        void Set(const Vector& pt);

        void SetZero();

        void Normalize();

        // MARK: Binary operations: new instance = this (+) v
        Vector Add(T v) const;

        Vector Add(const Vector& v) const;

        Vector Sub(T v) const;

        Vector Sub(const Vector& v) const;

        Vector Mul(T v) const;

        Vector Mul(const Vector& v) const;

        Vector Div(T v) const;

        Vector Div(const Vector& v) const;

        T Dot(const Vector& v) const;
        
        T Cross(const Vector& v) const;

        // MARK: Binary operations: new instance = v (+) this
        Vector RSub(T v) const;

        Vector RSub(const Vector& v) const;

        Vector RDiv(T v) const;

        Vector RDiv(const Vector& v) const;

        T RCross(const Vector& v) const;

        // MARK: Augmented operations: this (+)= v
        void IAdd(T v);

        void IAdd(const Vector& v);

        void ISub(T v);

        void ISub(const Vector& v);

        void IMul(T v);

        void IMul(const Vector& v);

        void IDiv(T v);

        void IDiv(const Vector& v);

        // MARK: Basic getters
        const T& At(size_t i) const;

        T& At(size_t i);

        T Sum() const;

        T Avg() const;

        T Min() const;

        T Max() const;

        T AbsMin() const;

        T AbsMax() const;

        size_t DominantAxis() const;

        size_t SubdominantAxis() const;

        Vector Normalized() const;

        T Length() const;

        T LengthSquared() const;

        T DistanceTo(const Vector& other) const;

        T DistanceSquaredTo(const Vector& other) const;

        Vector Reflected(const Vector& normal) const;

        Vector Projected(const Vector& normal) const;

        Vector Tangential() const;
         
        template <typename U>
        Vector<U, 2> CastTo() const;

        bool IsEqual(const Vector& other) const;

        bool IsSimilar(const Vector& other, T epsilon = std::numeric_limits<T>::epsilon()) const;

        // MARK: Operators
        T& operator[](size_t i);

        const T& operator[](size_t i) const;

        template <typename U>
        Vector& operator=(const std::initializer_list<U>& list);

        Vector& operator=(const Vector& v);

        Vector& operator+=(T v);

        Vector& operator+=(const Vector& v);

        Vector& operator-=(T v);

        Vector& operator-=(const Vector& v);

        Vector& operator*=(T v);

        Vector& operator*=(const Vector& v);

        Vector& operator/=(T v);

        Vector& operator/=(const Vector& v);

        bool operator==(const Vector& v) const;

        bool operator!=(const Vector& v) const;
    };

    template <typename T> using Vector2 = Vector<T, 2>;

    template <typename T>
    Vector<T, 2> operator+(const Vector<T, 2>& a);

    template <typename T>
    Vector<T, 2> operator-(const Vector<T, 2>& a);

    template <typename T>
    Vector<T, 2> operator+(T a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator+(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator-(const Vector<T, 2>& a, T b);

    template <typename T>
    Vector<T, 2> operator-(T a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator-(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator*(const Vector<T, 2>& a, T b);

    template <typename T>
    Vector<T, 2> operator*(T a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator*(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator/(const Vector<T, 2>& a, T b);

    template <typename T>
    Vector<T, 2> operator/(T a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> operator/(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> Min(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> Max(const Vector<T, 2>& a, const Vector<T, 2>& b);

    template <typename T>
    Vector<T, 2> Clamp(const Vector<T, 2>& v, const Vector<T, 2>& low, const Vector<T, 2>& high);

    template <typename T>
    Vector<T, 2> Ceil(const Vector<T, 2>& a);

    template <typename T>
    Vector<T, 2> Floor(const Vector<T, 2>& a);

    using Vector2F = Vector2<float>;

    using Vector2D = Vector2<double>;

    // MARK: Extensions
    template <>
    constexpr Vector<float, 2> Zero<Vector<float, 2>>()
    {
        return Vector<float, 2>(0.f, 0.f);
    }

    template <>
    constexpr Vector<double, 2> Zero<Vector<double, 2>>()
    {
        return Vector<double, 2>(0.0, 0.0);
    }

    template <typename T>
    struct ScalarType<Vector<T, 2>>
    {
        typedef T value;
    };

    template <typename T>
    Vector<T, 2> MonotonicCatmullRom(
        const Vector<T, 2>& v0,
        const Vector<T, 2>& v1,
        const Vector<T, 2>& v2,
        const Vector<T, 2>& v3,
        T f);
}

#include <Core/Vector/Vector2-Impl.h>

#endif