Point2.h

Go to the documentation of this file.

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

#include <Core/Point/Point.h>
#include <Core/Utils/Constants.h>

namespace CubbyFlow
{
    template <typename T>
    class Point<T, 2> final
    {
    public:
        static_assert(std::is_arithmetic<T>::value, "Point only can be instantiated with arithmetic types");

        T x;

        T y;

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

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

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

        constexpr Point(const Point& pt) : x(pt.x), y(pt.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 Point& pt);

        void SetZero();

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

        Point Add(const Point& v) const;

        Point Sub(T v) const;

        Point Sub(const Point& v) const;

        Point Mul(T v) const;

        Point Mul(const Point& v) const;

        Point Div(T v) const;

        Point Div(const Point& v) const;

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

        Point RAdd(const Point& v) const;

        Point RSub(T v) const;

        Point RSub(const Point& v) const;

        Point RMul(T v) const;

        Point RMul(const Point& v) const;

        Point RDiv(T v) const;

        Point RDiv(const Point& v) const;

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

        void IAdd(const Point& v);

        void ISub(T v);

        void ISub(const Point& v);

        void IMul(T v);

        void IMul(const Point& v);

        void IDiv(T v);

        void IDiv(const Point& v);

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

        T& At(size_t i);

        T Sum() const;

        T Min() const;

        T Max() const;

        T AbsMin() const;

        T AbsMax() const;

        size_t DominantAxis() const;

        size_t SubdominantAxis() const;

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

        bool IsEqual(const Point& other) const;

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

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

        Point& operator=(const std::initializer_list<T>& list);

        Point& operator=(const Point& v);

        Point& operator+=(T v);

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

        Point& operator-=(T v);

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

        Point& operator*=(T v);

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

        Point& operator/=(T v);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    template <typename T> using Point2 = Point<T, 2>;

    using Point2F = Point2<float>;

    using Point2D = Point2<double>;

    using Point2I = Point2<ssize_t>;

    using Point2UI = Point2<size_t>;
}

#include <Core/Point/Point2-Impl.h>

#endif