Vector3.h

Go to the documentation of this file.

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

#include <Core/Vector/Vector2.h>

#include <limits>

namespace CubbyFlow
{
    template <typename T>
    class Vector<T, 3> 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;

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

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

        constexpr Vector(const Vector2<T>& v, T _z) : x(v.x), y(v.y), z(_z)
        {
            // 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)
        {
            // Do nothing
        }

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

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

        void Set(const Vector2<T>& 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;

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

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

        std::tuple<Vector<T, 3>, Vector<T, 3>> Tangential() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    using Vector3F = Vector3<float>;

    using Vector3D = Vector3<double>;

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

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

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

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

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

#endif