size3.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_SIZE3_H_
#define INCLUDE_JET_SIZE3_H_
 
#include <jet/size2.h>
 
namespace jet {
 
class Size3 {
 public:
    size_t x;
 
    size_t y;
 
    size_t z;
 
    // MARK: Constructors
 
    constexpr Size3() : x(0), y(0), z(0) {}
 
    constexpr Size3(size_t x_, size_t y_, size_t z_) : x(x_), y(y_), z(z_) {}
 
    constexpr Size3(const Size2& v, size_t z_) : x(v.x), y(v.y), z(z_) {}
 
    template <typename U>
    Size3(const std::initializer_list<U>& lst);
 
    constexpr Size3(const Size3& v) : x(v.x), y(v.y), z(v.z) {}
 
    // MARK: Basic setters
 
    void set(size_t s);
 
    void set(size_t x, size_t y, size_t z);
 
    void set(const Size2& sz, size_t z);
 
    template <typename U>
    void set(const std::initializer_list<U>& lst);
 
    void set(const Size3& v);
 
    void setZero();
 
    // MARK: Binary operations: new instance = this (+) v
 
    Size3 add(size_t v) const;
 
    Size3 add(const Size3& v) const;
 
    Size3 sub(size_t v) const;
 
    Size3 sub(const Size3& v) const;
 
    Size3 mul(size_t v) const;
 
    Size3 mul(const Size3& v) const;
    Size3 div(size_t v) const;
 
    Size3 div(const Size3& v) const;
 
    // MARK: Binary operations: new instance = v (+) this
 
    Size3 rsub(size_t v) const;
 
    Size3 rsub(const Size3& v) const;
 
    Size3 rdiv(size_t v) const;
 
    Size3 rdiv(const Size3& v) const;
 
    // MARK: Augmented operations: this (+)= v
 
    void iadd(size_t v);
 
    void iadd(const Size3& v);
 
    void isub(size_t v);
 
    void isub(const Size3& v);
 
    void imul(size_t v);
 
    void imul(const Size3& v);
 
    void idiv(size_t v);
 
    void idiv(const Size3& v);
 
    // MARK: Basic getters
 
    const size_t& at(size_t i) const;
 
    size_t& at(size_t i);
 
    size_t sum() const;
 
    size_t min() const;
 
    size_t max() const;
 
    size_t absmin() const;
 
    size_t absmax() const;
 
    size_t dominantAxis() const;
 
    size_t subminantAxis() const;
 
    bool isEqual(const Size3& other) const;
 
    // MARK: Operators
 
    size_t& operator[](size_t i);
 
    const size_t& operator[](size_t i) const;
 
    template <typename U>
    Size3& operator=(const std::initializer_list<U>& lst);
 
    Size3& operator=(const Size3& v);
 
    Size3& operator+=(size_t v);
 
    Size3& operator+=(const Size3& v);
 
    Size3& operator-=(size_t v);
 
    Size3& operator-=(const Size3& v);
 
    Size3& operator*=(size_t v);
 
    Size3& operator*=(const Size3& v);
 
    Size3& operator/=(size_t v);
 
    Size3& operator/=(const Size3& v);
 
    bool operator==(const Size3& v) const;
 
    bool operator!=(const Size3& v) const;
};
 
Size3 operator+(const Size3& a);
 
Size3 operator-(const Size3& a);
 
Size3 operator+(size_t a, const Size3& b);
 
Size3 operator+(const Size3& a, const Size3& b);
 
Size3 operator-(const Size3& a, size_t b);
 
Size3 operator-(size_t a, const Size3& b);
 
Size3 operator-(const Size3& a, const Size3& b);
 
Size3 operator*(const Size3& a, size_t b);
 
Size3 operator*(size_t a, const Size3& b);
 
Size3 operator*(const Size3& a, const Size3& b);
 
Size3 operator/(const Size3& a, size_t b);
 
Size3 operator/(size_t a, const Size3& b);
 
Size3 operator/(const Size3& a, const Size3& b);
 
Size3 min(const Size3& a, const Size3& b);
 
Size3 max(const Size3& a, const Size3& b);
 
Size3 clamp(const Size3& v, const Size3& low, const Size3& high);
 
Size3 ceil(const Size3& a);
 
Size3 floor(const Size3& a);
 
}  // namespace jet
 
#include "detail/size3-inl.h"
 
#endif  // INCLUDE_JET_SIZE3_H_