Point3.h

Go to the documentation of this file.

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

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

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

        T x;

        T y;

        T z;

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

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

        constexpr Point(const Point2<T>& pt, T _z) : x(pt.x), y(pt.y), z(_z) 
        {
            // Do nothing
        }

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

        constexpr Point(const Point& pt) : x(pt.x), y(pt.y), z(pt.z)
        {
            // Do nothing
        }

        // MARK: Basic setters
        void Set(T s);
        
        void Set(T x, T y, T z);

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

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

        void Set(const Point& v);

        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, 3> 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, 3> operator+(const Point<T, 3>& a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    template <typename T> using Point3 = Point<T, 3>;

    using Point3F = Point3<float>;

    using Point3D = Point3<double>;

    using Point3I = Point3<ssize_t>;

    using Point3UI = Point3<size_t>;
}

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

#endif