#pragma once
#ifndef TCG_SIZE_H
#define TCG_SIZE_H
namespace tcg
{
//**********************************************************************************
// Bidimensional size class
//**********************************************************************************
template <typename T>
struct SizeT {
typedef T value_type;
public:
T w, h;
public:
SizeT() : w(), h() {}
SizeT(T w_, T h_) : w(w_), h(h_) {}
bool empty() const { return (w <= 0) || (h <= 0); }
SizeT &operator+=(const SizeT &other)
{
w += other.w, h += other.h;
return *this;
}
SizeT &operator-=(const SizeT &other)
{
w -= other.w, h -= other.h;
return *this;
}
friend SizeT<T> operator+(const SizeT<T> &a, const SizeT<T> &b)
{
return SizeT<T>(a.w + b.w, a.h + b.h);
}
friend SizeT<T> operator-(const SizeT<T> &a, const SizeT<T> &b)
{
return SizeT<T>(a.w - b.w, a.h - b.h);
}
template <typename K>
SizeT &operator*=(K k)
{
w *= k, h *= k;
return *this;
}
template <typename K>
SizeT &operator/=(K k)
{
w /= k, h /= k;
return *this;
}
template <typename K>
friend SizeT<T> operator*(K k, const SizeT<T> &a)
{
return SizeT<T>(k * a.w, k * a.h);
}
template <typename K>
friend SizeT<T> operator*(const SizeT<T> &a, K k)
{
return SizeT<T>(a.w * k, a.h * k);
}
template <typename K>
friend SizeT<T> operator/(const SizeT<T> &a, K k)
{
return SizeT<T>(a.w / k, a.h / k);
}
SizeT &operator&=(const SizeT &other)
{
if (other.w < w)
w = other.w;
if (other.h < h)
h = other.h;
return *this;
}
SizeT &operator|=(const SizeT &other)
{
if (other.w > w)
w = other.w;
if (other.h > h)
h = other.h;
return *this;
}
friend SizeT<T> operator&(const SizeT<T> &a, const SizeT<T> &b)
{
SizeT<T> tmp(a);
return tmp &= b;
}
friend SizeT<T> operator|(const SizeT<T> &a, const SizeT<T> &b)
{
SizeT<T> tmp(a);
return tmp |= b;
}
};
//------------------------------------------------------------------------
typedef SizeT<int> SizeI;
typedef SizeI Size;
typedef SizeT<double> SizeD;
//**********************************************************************************
// Tridimensional size class
//**********************************************************************************
template <typename T>
struct Size3T {
typedef T value_type;
public:
T w, h, d;
public:
Size3T() : w(), h(), d() {}
Size3T(T w_, T h_, T d_) : w(w_), h(h_), d(d_) {}
bool empty() const { return (w <= 0) || (h <= 0) || (d <= 0); }
Size3T &operator+=(const Size3T &other)
{
w += other.w, h += other.h, d += other.d;
return *this;
}
Size3T &operator-=(const Size3T &other)
{
w -= other.w, h -= other.h, d -= other.d;
return *this;
}
friend Size3T<T> operator+(const Size3T<T> &a, const Size3T<T> &b)
{
return SizeT<T>(a.w + b.w, a.h + b.h, a.d + b.d);
}
friend Size3T<T> operator-(const Size3T<T> &a, const Size3T<T> &b)
{
return SizeT<T>(a.w - b.w, a.h - b.h, a.d + b.d);
}
template <typename K>
Size3T &operator*=(K k)
{
w *= k, h *= k, d *= k;
return *this;
}
template <typename K>
Size3T &operator/=(K k)
{
w /= k, h /= k, d /= k;
return *this;
}
template <typename K>
friend Size3T<T> operator*(K k, const Size3T<T> &a)
{
return Size3T<T>(k * a.w, k * a.h, k * a.d);
}
template <typename K>
friend Size3T<T> operator*(const Size3T<T> &a, K k)
{
return Size3T<T>(a.w * k, a.h * k, a.d * k);
}
template <typename K>
friend Size3T<T> operator/(const Size3T<T> &a, K k)
{
return Size3T<T>(a.w / k, a.h / k, a.d / k);
}
Size3T &operator&=(const Size3T &other)
{
if (other.w < w)
w = other.w;
if (other.h < h)
h = other.h;
if (other.d < d)
d = other.d;
return *this;
}
Size3T &operator|=(const Size3T &other)
{
if (other.w > w)
w = other.w;
if (other.h > h)
h = other.h;
if (other.d > d)
d = other.d;
return *this;
}
friend Size3T<T> operator&(const Size3T<T> &a, const Size3T<T> &b)
{
Size3T<T> tmp(a);
return tmp &= b;
}
friend Size3T<T> operator|(const Size3T<T> &a, const Size3T<T> &b)
{
Size3T<T> tmp(a);
return tmp |= b;
}
};
//------------------------------------------------------------------------
typedef Size3T<int> Size3I;
typedef Size3I Size3;
typedef Size3T<double> Size3D;
//**********************************************************************************
// N-dimensional size class
//**********************************************************************************
template <int N, typename T>
struct SizeN {
static const int size = N;
typedef T value_type;
public:
T span[N];
public:
SizeN() {}
SizeN(const T &t) { std::fill(span, span + N, t); }
template <typename It>
SizeN(It begin, It end)
{
std::copy(begin, end, span);
}
// To be completed...
};
} // namespace tcg
#endif // TCG_SIZE_H