Vector4.h

Go to the documentation of this file.

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

#include <Core/Vector/Vector3.h>

#include <limits>

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

        T x;

        T y;

        T z;

        T w;

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

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

        constexpr Vector(const Vector<T, 3>& v, T _w) : x(v.x), y(v.y), z(v.z), w(_w)
        {
            // Do nothing
        }

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

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

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

        void Set(T x, T y, T z, T w);

        void Set(const Vector<T, 3>& pt, T z);

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

        void Set(const Vector& v);

        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;

        // 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;

        // 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;

        template <typename U>
        Vector<U, 4> 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 Vector4 = Vector<T, 4>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    using Vector4F = Vector4<float>;

    using Vector4D = Vector4<double>;

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

    template <>
    constexpr Vector4D Zero<Vector4D>()
    {
        return Vector4D(0.0, 0.0, 0.0, 0.0);
    }

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

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

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

#endif