path: root/src/utils/rectangle.hpp

/*
 * UltraStar Deluxe - Karaoke Game
 *
 * UltraStar Deluxe is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#ifndef RECTANGLE_HPP
#define RECTANGLE_HPP

#include "point.hpp"
#include "dimension.hpp"
#include "math.hpp"

namespace usdx
{
	template <class T>
	class Rectangle
	{
	private:
		Point<T> point1;
		Point<T> point2;

	public:
		Rectangle(T x1, T y1, T x2, T y2) :
			point1(x1, y1), point2(x2, y2)
		{
		}

		Rectangle(const Point<T>& point1, const Point<T>& point2) :
			point1(point1), point2(point2)
		{
		}

		Rectangle(const Point<T>& point1, T width, T height) :
			point1(point1),
			point2(point1.get_x() + width, point1.get_y() + height)
		{
		}

		Rectangle(const Point<T>& point1, const Dimension<T>& dimension) :
			point1(point1),
			point2(point1.get_x() + dimension.get_width(),
				   point1.get_y() + dimension.get_height())
		{
		}

		Rectangle(const Rectangle<T>& rectangle) :
			point1(rectangle.point1), point2(rectangle.point2)
		{
		}


		Point<T>& get_point1(void)
		{
			return point1;
		}

		Point<T>& get_point2(void)
		{
			return point2;
		}

		const T get_width(void) const
		{
			return Math::abs(point2.get_x() - point1.get_x());
		}

		const T get_height(void) const
		{
			return Math::abs(point2.get_y() - point1.get_y());
		}

		const T get_top(void) const
		{
			return Math::min(point1.get_y(), point2.get_y());
		}

		void set_top(T value)
		{
			T height = get_height();
			point1.set_y(value);
			point2.set_y(value + height);
		}

		const T get_bottom(void) const
		{
			return Math::max(point1.get_y(), point2.get_y());
		}

		const T get_left(void) const
		{
			return Math::min(point1.get_x(), point2.get_x());
		}

		void set_left(T value)
		{
			T width = get_width();
			point1.set_x(value);
			point2.set_x(value + width);
		}

		const Dimension<T> get_dim() const
		{
			return Dimension<T> (get_width(), get_height());
		}

		const T get_right(void) const
		{
			return Math::max(point1.get_x(), point2.get_x());
		}

		const Rectangle<T> intersect(const Rectangle<T>& inner) const
		{
			Rectangle<T> result(*this);

			if (inner.point1.get_x() > result.point1.get_x()) {
				result.point1.set_x(inner.point1.get_x());
			}

			if (inner.point1.get_y() > result.point1.get_y()) {
				result.point1.set_y(inner.point1.get_y());
			}

			if (inner.point2.get_x() < result.point2.get_x()) {
				result.point2.set_x(inner.point2.get_x());
			}

			if (inner.point2.get_y() < result.point2.get_y()) {
				result.point2.set_y(inner.point2.get_y());
			}

			return result;
		}

		const Rectangle<T> operator+(const Point<T>& offset)
		{
			Rectangle<T> tmp(*this);
			tmp += offset;
			return tmp;
		}

		Rectangle<T>& operator+=(const Point<T>& offset)
		{
			T height = this->get_height();
			T width = this->get_width();
			T left = this->get_left() + offset.get_x();
			T top = this->get_top() + offset.get_y();

			this->point1 = Point<T>(left, top);
			this->point2 = Point<T>(left + width, top + height);
			return *this;
		}

		bool is_in(const Point<T>& p) const
		{
			if (p.get_x() < get_left())
				return false;
			if (p.get_x() > get_right())
				return false;

			if (p.get_y() < get_top())
				return false;
			if (p.get_y() > get_bottom())
				return false;

			return true;
		}
	};
}

#endif