rect.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <promeki/core/namespace.h>
#include <promeki/core/point.h>
#include <promeki/core/size2d.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class Rect {
        public:
                Rect() = default;
 
                Rect(const Point<T, 2> &pos, const Size2DTemplate<T> &size)
                        : _pos(pos), _size(size) {}
 
                Rect(T x, T y, T width, T height)
                        : _pos(x, y), _size(width, height) {}
 
                T x() const { return _pos.x(); }
 
                T y() const { return _pos.y(); }
 
                T width() const { return _size.width(); }
 
                T height() const { return _size.height(); }
 
                void setX(T val) { _pos.setX(val); }
 
                void setY(T val) { _pos.setY(val); }
 
                void setWidth(T val) { _size.setWidth(val); }
 
                void setHeight(T val) { _size.setHeight(val); }
 
                Point<T, 2> topLeft() const { return _pos; }
 
                Point<T, 2> topRight() const { return Point<T, 2>(x() + width(), y()); }
 
                Point<T, 2> bottomLeft() const { return Point<T, 2>(x(), y() + height()); }
 
                Point<T, 2> bottomRight() const { return Point<T, 2>(x() + width(), y() + height()); }
 
                Point<T, 2> center() const { return Point<T, 2>(x() + width() / 2, y() + height() / 2); }
 
                const Point<T, 2> &pos() const { return _pos; }
 
                const Size2DTemplate<T> &size() const { return _size; }
 
                void setPos(const Point<T, 2> &p) { _pos = p; }
 
                void setSize(const Size2DTemplate<T> &s) { _size = s; }
 
                bool isValid() const { return _size.isValid(); }
 
                bool isEmpty() const { return !isValid(); }
 
                bool contains(const Point<T, 2> &p) const {
                        return p.x() >= x() && p.x() < x() + width() &&
                               p.y() >= y() && p.y() < y() + height();
                }
 
                bool contains(const Rect &r) const {
                        return r.x() >= x() && r.x() + r.width() <= x() + width() &&
                               r.y() >= y() && r.y() + r.height() <= y() + height();
                }
 
                bool intersects(const Rect &r) const {
                        return x() < r.x() + r.width() && x() + width() > r.x() &&
                               y() < r.y() + r.height() && y() + height() > r.y();
                }
 
                Rect intersected(const Rect &r) const {
                        T ix = std::max(x(), r.x());
                        T iy = std::max(y(), r.y());
                        T ix2 = std::min(x() + width(), r.x() + r.width());
                        T iy2 = std::min(y() + height(), r.y() + r.height());
                        if(ix2 <= ix || iy2 <= iy) return Rect();
                        return Rect(ix, iy, ix2 - ix, iy2 - iy);
                }
 
                Rect united(const Rect &r) const {
                        if(isEmpty()) return r;
                        if(r.isEmpty()) return *this;
                        T ux = std::min(x(), r.x());
                        T uy = std::min(y(), r.y());
                        T ux2 = std::max(x() + width(), r.x() + r.width());
                        T uy2 = std::max(y() + height(), r.y() + r.height());
                        return Rect(ux, uy, ux2 - ux, uy2 - uy);
                }
 
                Rect adjusted(T dx1, T dy1, T dx2, T dy2) const {
                        return Rect(x() + dx1, y() + dy1,
                                    width() + dx2 - dx1, height() + dy2 - dy1);
                }
 
                Rect translated(T dx, T dy) const {
                        return Rect(x() + dx, y() + dy, width(), height());
                }
 
                bool operator==(const Rect &other) const {
                        return _pos == other._pos && _size.width() == other._size.width() &&
                               _size.height() == other._size.height();
                }
 
                bool operator!=(const Rect &other) const {
                        return !(*this == other);
                }
 
        private:
                Point<T, 2>            _pos;
                Size2DTemplate<T>      _size;
};
 
using Rect2Di32 = Rect<int32_t>;
using Rect2Df = Rect<float>;
using Rect2Dd = Rect<double>;
 
PROMEKI_NAMESPACE_END