#ifndef TCG_RECT_H

#define TCG_RECT_H

#include "point.h"

#include "size.h"

// STD includes

#include <limits></limits>

namespace tcg

{

//**********************************************************************************

//    Bidimensional Rect  class

//**********************************************************************************

template <typename t=""></typename>

struct RectT {

	T x0, y0,

		x1, y1;

public:

	RectT() : x0((std::numeric_limits<t>::max)()), y0(x0), x1(-x0), y1(x1) {}</t>

	RectT(T x0_, T y0_, T x1_, T y1_)

		: x0(x0_), y0(y0_), x1(x1_), y1(y1_) {}

	RectT(const PointT<t> &p0, const PointT<t> &p1)</t></t>

		: x0(p0.x), y0(p0.y), x1(p1.x), y1(p1.y) {}

	RectT(const PointT<t> &p0, const SizeT<t> &size)</t></t>

		: x0(p0.x), y0(p0.y), x1(p0.x + size.w), y1(p0.y + size.h) {}

	bool empty() const { return (x1 <= x0) || (y1 <= y0); }

	PointT<t> p0() const { return PointT<t>(x0, y0); }</t></t>

	PointT<t> p1() const { return PointT<t>(x1, y1); }</t></t>

	PointT<t> center() const</t>

	{

		return PointT<t>((x0 + x1) / 2, (y0 + y1) / 2);</t>

	}

	T width() const { return x1 - x0; }

	T height() const { return y1 - y0; }

	SizeT<t> size() const { return SizeT<t>(width(), height()); }</t></t>

	bool operator==(const RectT &other) const

	{

		return x0 == other.x0 && y0 == other.y0 && x1 == other.x1 && y1 == other.y1;

	}

	bool operator!=(const RectT &other) const { return !operator==(other); }

	RectT &operator+=(const PointT<t> &p)</t>

	{

		x0 += p.x, y0 += p.y, x1 += p.x, y1 += p.y;

		return *this;

	}

	RectT &operator-=(const PointT<t> &p)</t>

	{

		x0 -= p.x, y0 -= p.y, x1 -= p.x, y1 -= p.y;

		return *this;

	}

	friend RectT<t> operator+(const RectT<t> &r, const tcg::PointT<t> &p)</t></t></t>

	{

		return RectT<t>(r.x0 + p.x, r.y0 + p.y, r.x1 + p.x, r.y1 + p.y);</t>

	}

	friend RectT<t> operator-(const RectT<t> &r, const tcg::PointT<t> &p)</t></t></t>

	{

		return RectT<t>(r.x0 - p.x, r.y0 - p.y, r.x1 - p.x, r.y1 - p.y);</t>

	}

	friend RectT<t> operator+(const tcg::PointT<t> &p, const RectT<t> &r)</t></t></t>

	{

		return RectT<t>(p.x + r.x0, p.y + r.y0, p.x + r.x1, p.y + r.y1);</t>

	}

	friend RectT<t> operator-(const tcg::PointT<t> &p, const RectT<t> &r)</t></t></t>

	{

		return RectT<t>(p.x - r.x0, p.y - r.y0, p.x - r.x1, p.y - r.y1);</t>

	}

	template <typename k=""></typename>

	RectT &operator*=(K k)

	{

		x0 *= k, y0 *= k, x1 *= k, y1 *= k;

		return *this;

	}

	template <typename k=""></typename>

	friend RectT<t> operator*(const RectT<t> &r, K k)</t></t>

	{

		return RectT<t>(r.x0 * k, r.y0 * k, r.x1 * k, r.y1 * k);</t>

	}

	template <typename k=""></typename>

	friend RectT<t> operator*(K k, const RectT<t> &r)</t></t>

	{

		return RectT<t>(k * r.x0, k * r.y0, k * r.x1, k * r.y1);</t>

	}

	RectT &operator|=(const RectT &other)

	{

		if (x0 > other.x0)

			x0 = other.x0;

		if (y0 > other.y0)

			y0 = other.y0;

		if (x1 < other.x1)

			x1 = other.x1;

		if (y1 < other.y1)

			y1 = other.y1;

		return *this;

	}

	RectT &operator&=(const RectT &other)

	{

		if (x0 < other.x0)

			x0 = other.x0;

		if (y0 < other.y0)

			y0 = other.y0;

		if (x1 > other.x1)

			x1 = other.x1;

		if (y1 > other.y1)

			y1 = other.y1;

		return *this;

	}

	RectT &operator|=(const PointT<t> &p)</t>

	{

		return operator|=(RectT(p.x, p.y, p.x, p.y));

	}

	RectT &operator&=(const PointT<t> &p)</t>

	{

		return operator&=(RectT(p.x, p.y, p.x, p.y));

	}

	friend RectT<t> operator|(const RectT<t> &a, const RectT<t> &b)</t></t></t>

	{

		return RectT<t>(a) |= b;</t>

	}

	friend RectT<t> operator&(const RectT<t> &a, const RectT<t> &b)</t></t></t>

	{

		return RectT<t>(a) &= b;</t>

	}

	friend RectT<t> operator|(const RectT<t> &r, const PointT<t> &p)</t></t></t>

	{

		return RectT<t>(r) |= p;</t>

	}

	friend RectT<t> operator&(const RectT<t> &r, const PointT<t> &p)</t></t></t>

	{

		return RectT<t>(r) &= p;</t>

	}

	friend RectT<t> operator|(const PointT<t> &p, const RectT<t> &r)</t></t></t>

	{

		return RectT<t>(r) |= p;</t>

	}

	friend RectT<t> operator&(const PointT<t> &p, const RectT<t> &r)</t></t></t>

	{

		return RectT<t>(r) &= p;</t>

	}

};

//------------------------------------------------------------------------

typedef RectT<double> RectD;</double>

typedef RectT<int> RectI;</int>

typedef RectI Rect;

//**********************************************************************************

//    Tridimensional Rect  class

//**********************************************************************************

template <typename t=""></typename>

struct Rect3T {

	T x0, y0, z0,

		x1, y1, z1;

public:

	Rect3T() : x0((std::numeric_limits<t>::max)()), y0(x0), z0(x0), x1(-x0), y1(x1), z1(x1) {}</t>

	Rect3T(T x0_, T y0_, T z0_, T x1_, T y1_, T z1_)

		: x0(x0_), y0(y0_), z0(z0_), x1(x1_), y1(y1_), z1(z1_) {}

	Rect3T(const Point3T<t> &p0, const Point3T<t> &p1)</t></t>

		: x0(p0.x), y0(p0.y), z0(p0.z) x1(p1.x), y1(p1.y), z1(p1.z) {}

	Rect3T(const Point3T<t> &p0, const Size3T<t> &size)</t></t>

		: x0(p0.x), y0(p0.y), z0(p0.z), x1(p0.x + size.w), y1(p0.y + size.h), z1(p0.z + size.d) {}

	bool empty() const { return (x1 <= x0) || (y1 <= y0) || (z1 <= z0); }

	Point3T<t> p0() const { return Point3T<t>(x0, y0, z0); }</t></t>

	Point3T<t> p1() const { return Point3T<t>(x1, y1, z1); }</t></t>

	Point3T<t> center() const</t>

	{

		return Point3T<t>((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2);</t>

	}

	T width() const { return x1 - x0; }

	T height() const { return y1 - y0; }

	T depth() const { return z1 - z0; }

	Size3T<t> size() const { return Size3T<t>(width(), height(), depth()); }</t></t>

	bool operator==(const Rect3T &other) const

	{

		return x0 == other.x0 && y0 == other.y0 && z0 == other.z0 && x1 == other.x1 && y1 == other.y1 && z1 == other.z1;

	}

	bool operator!=(const Rect3T &other) const { return !operator==(other); }

	Rect3T &operator+=(const Point3T<t> &p)</t>

	{

		x0 += p.x, y0 += p.y, z0 += p.z, x1 += p.x, y1 += p.y, z1 += p.z;

		return *this;

	}

	Rect3T &operator-=(const Point3T<t> &p)</t>

	{

		x0 -= p.x, y0 -= p.y, z0 -= p.z, x1 -= p.x, y1 -= p.y, z1 -= p.z;

		return *this;

	}

	friend Rect3T<t> operator+(const Rect3T<t> &r, const tcg::Point3T<t> &p)</t></t></t>

	{

		return Rect3T<t>(r.x0 + p.x, r.y0 + p.y, r.z0 + p.z,</t>

						 r.x1 + p.x, r.y1 + p.y, r.z1 + p.z);

	}

	friend Rect3T<t> operator-(const Rect3T<t> &r, const tcg::Point3T<t> &p)</t></t></t>

	{

		return Rect3T<t>(r.x0 - p.x, r.y0 - p.y, r.z0 - p.z,</t>

						 r.x1 - p.x, r.y1 - p.y, r.z1 - p.z);

	}

	friend Rect3T<t> operator+(const tcg::Point3T<t> &p, const Rect3T<t> &r)</t></t></t>

	{

		return Rect3T<t>(p.x + r.x0, p.x + r.y0, p.x + r.z0,</t>

						 p.x + r.x1 + p.x, r.y1, p.x + r.z1);

	}

	friend Rect3T<t> operator-(const tcg::Point3T<t> &p, const Rect3T<t> &r)</t></t></t>

	{

		return Rect3T<t>(p.x - r.x0, p.y - r.y0, p.z - r.z0,</t>

						 p.x - r.x1, p.y - r.y1, p.z - r.z1);

	}

	template <typename k=""></typename>

	Rect3T &operator*=(K k)

	{

		x0 *= k, y0 *= k, z0 *= k, x1 *= k, y1 *= k, z1 *= k;

		return *this;

	}

	template <typename k=""></typename>

	friend Rect3T<t> operator*(const Rect3T<t> &r, K k)</t></t>

	{

		return RectT<t>(r.x0 * k, r.y0 * k, r.z0 * k,</t>

						r.x1 * k, r.y1 * k, r.z1 * k);

	}

	template <typename k=""></typename>

	friend Rect3T<t> operator*(K k, const Rect3T<t> &r)</t></t>

	{

		return RectT<t>(k * r.x0, k * r.y0, k * r.z0,</t>

						k * r.x1, k * r.y1, k * r.z1);

	}

	Rect3T &operator|=(const Rect3T &other)

	{

		if (x0 > other.x0)

			x0 = other.x0;

		if (y0 > other.y0)

			y0 = other.y0;

		if (z0 > other.z0)

			z0 = other.z0;

		if (x1 < other.x1)

			x1 = other.x1;

		if (y1 < other.y1)

			y1 = other.y1;

		if (z1 < other.z1)

			z1 = other.z1;

		return *this;

	}

	Rect3T &operator&=(const Rect3T &other)

	{

		if (x0 < other.x0)

			x0 = other.x0;

		if (y0 < other.y0)

			y0 = other.y0;

		if (z0 < other.z0)

			z0 = other.z0;

		if (x1 > other.x1)

			x1 = other.x1;

		if (y1 > other.y1)

			y1 = other.y1;

		if (z1 > other.z1)

			z1 = other.z1;

		return *this;

	}

	Rect3T &operator|=(const Point3T<t> &p)</t>

	{

		return operator|=(RectT(p.x, p.y, p.z, p.x, p.y, p.z));

	}

	Rect3T &operator&=(const Point3T<t> &p)</t>

	{

		return operator&=(RectT(p.x, p.y, p.z, p.x, p.y, p.z));

	}

	friend Rect3T<t> operator|(const Rect3T<t> &a, const Rect3T<t> &b)</t></t></t>

	{

		return Rect3T<t>(a) |= b;</t>

	}

	friend Rect3T<t> operator&(const Rect3T<t> &a, const Rect3T<t> &b)</t></t></t>

	{

		return Rect3T<t>(a) &= b;</t>

	}

	friend Rect3T<t> operator|(const Rect3T<t> &r, const Point3T<t> &p)</t></t></t>

	{

		return Rect3T<t>(r) |= p;</t>

	}

	friend Rect3T<t> operator&(const Rect3T<t> &r, const Point3T<t> &p)</t></t></t>

	{

		return Rect3T<t>(r) &= p;</t>

	}

	friend Rect3T<t> operator|(const Point3T<t> &p, const Rect3T<t> &r)</t></t></t>

	{

		return Rect3T<t>(r) |= p;</t>

	}

	friend Rect3T<t> operator&(const Point3T<t> &p, const Rect3T<t> &r)</t></t></t>

	{

		return Rect3T<t>(r) &= p;</t>

	}

};

//------------------------------------------------------------------------

typedef Rect3T<double> Rect3D;</double>

typedef Rect3T<int> Rect3I;</int>

typedef RectI Rect;

} // namespace tcg

#endif // TCG_RECT_H