rect.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM 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 3 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.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef COMMON_RECT_H
#define COMMON_RECT_H
 
#include "common/scummsys.h"
#include "common/util.h"
#include "common/debug.h"
#include "common/str.h"
 
#define PRINT_RECT(x) (x).left,(x).top,(x).right,(x).bottom
 
namespace Common {
 
template<typename T, typename ConcretePoint>
struct PointBase {
    T x;    
    T y;    
    constexpr PointBase() : x(0), y(0) {}
 
    constexpr PointBase(T x1, T y1) : x(x1), y(y1) {}
    bool  operator==(const ConcretePoint &p)    const { return x == p.x && y == p.y; }
    bool  operator!=(const ConcretePoint &p)    const { return x != p.x || y != p.y; }
    ConcretePoint operator+(const ConcretePoint &delta) const { return ConcretePoint(x + delta.x, y + delta.y); }
    ConcretePoint operator-(const ConcretePoint &delta) const { return ConcretePoint(x - delta.x, y - delta.y); }
    ConcretePoint operator/(int divisor) const { return ConcretePoint(x / divisor, y / divisor); }
    ConcretePoint operator*(int multiplier) const { return ConcretePoint(x * multiplier, y * multiplier); }
    ConcretePoint operator/(double divisor) const { return ConcretePoint((T)(x / divisor), (T)(y / divisor)); }
    ConcretePoint operator*(double multiplier) const { return ConcretePoint((T)(x * multiplier), (T)(y * multiplier)); }
 
    void operator+=(const ConcretePoint &delta) {
        x += delta.x;
        y += delta.y;
    }
 
    void operator-=(const ConcretePoint &delta) {
        x -= delta.x;
        y -= delta.y;
    }
 
    uint sqrDist(const ConcretePoint &p) const {
        int diffx = ABS(p.x - x);
        if (diffx >= 0x1000)
            return 0xFFFFFF;
 
        int diffy = ABS(p.y - y);
        if (diffy >= 0x1000)
            return 0xFFFFFF;
 
        return uint(diffx * diffx + diffy * diffy);
    }
 
    String toString() const {
        return String::format("%d, %d", x, y);
    }
};
 
#define BEGIN_POINT_TYPE(T, Point) \
    struct Point : public Common::PointBase<T, Point> {
#define END_POINT_TYPE(T, Point) \
        constexpr Point() : PointBase() {} \
        constexpr Point(T x1, T y1) : PointBase(x1, y1) {} \
    }; \
    static inline Point operator*(int multiplier, const Point &p) { return Point(p.x * multiplier, p.y * multiplier); } \
    static inline Point operator*(double multiplier, const Point &p) { return Point((T)(p.x * multiplier), (T)(p.y * multiplier)); }
 
BEGIN_POINT_TYPE(int16, Point)
END_POINT_TYPE(int16, Point)
BEGIN_POINT_TYPE(int32, Point32)
        constexpr Point32(const Point &o) : PointBase(o.x, o.y) {}
END_POINT_TYPE(int32, Point32)
 
 
template<typename T, typename ConcreteRect, typename ConcretePoint>
struct RectBase {
    T top, left;        
    T bottom, right;    
    constexpr RectBase() : top(0), left(0), bottom(0), right(0) {}
    constexpr RectBase(T w, T h) : top(0), left(0), bottom(h), right(w) {}
    RectBase(const ConcretePoint &topLeft, const ConcretePoint &bottomRight) : top(topLeft.y), left(topLeft.x), bottom(bottomRight.y), right(bottomRight.x) {
        assert(isValidRect());
    }
    constexpr RectBase(const ConcretePoint &topLeft, T w, T h) : top(topLeft.y), left(topLeft.x), bottom(topLeft.y + h), right(topLeft.x + w) {
    }
    RectBase(T x1, T y1, T x2, T y2) : top(y1), left(x1), bottom(y2), right(x2) {
        assert(isValidRect());
    }
    bool operator==(const ConcreteRect &rhs) const { return equals(rhs); }
    bool operator!=(const ConcreteRect &rhs) const { return !equals(rhs); }
 
    ConcretePoint origin() const { return ConcretePoint(left, top); } 
    T width() const { return right - left; }                          
    T height() const { return bottom - top; }                         
    void setWidth(T aWidth) {   
        right = left + aWidth;
    }
 
    void setHeight(T aHeight) { 
        bottom = top + aHeight;
    }
 
    void setRect(T newLeft, T newTop, T newRight, T newBottom) {
        left   = newLeft;
        top    = newTop;
        right  = newRight;
        bottom = newBottom;
    }
 
    bool contains(T x, T y) const {
        return (left <= x) && (x < right) && (top <= y) && (y < bottom);
    }
 
    bool contains(const ConcretePoint &p) const {
        return contains(p.x, p.y);
    }
 
    bool contains(const ConcreteRect &r) const {
        return (left <= r.left) && (r.right <= right) && (top <= r.top) && (r.bottom <= bottom);
    }
 
    bool equals(const ConcreteRect &r) const {
        return (left == r.left) && (right == r.right) && (top == r.top) && (bottom == r.bottom);
    }
 
    bool intersects(const ConcreteRect &r) const {
        return (left < r.right) && (r.left < right) && (top < r.bottom) && (r.top < bottom);
    }
 
    ConcreteRect findIntersectingRect(const ConcreteRect &r) const {
        if (!intersects(r))
            return ConcreteRect();
 
        return ConcreteRect(MAX(r.left, left), MAX(r.top, top), MIN(r.right, right), MIN(r.bottom, bottom));
    }
 
    void extend(const ConcreteRect &r) {
        left = MIN(left, r.left);
        right = MAX(right, r.right);
        top = MIN(top, r.top);
        bottom = MAX(bottom, r.bottom);
    }
 
    void extend(const ConcretePoint &p) {
        left = MIN(left, p.x);
        right = MAX(right, p.x);
        top = MIN(top, p.y);
        bottom = MAX(bottom, p.y);
    }
 
    void grow(T offset) {
        top -= offset;
        left -= offset;
        bottom += offset;
        right += offset;
    }
 
    void clip(const ConcreteRect &r) {
        assert(isValidRect());
        assert(r.isValidRect());
 
        if (top < r.top) top = r.top;
        else if (top > r.bottom) top = r.bottom;
 
        if (left < r.left) left = r.left;
        else if (left > r.right) left = r.right;
 
        if (bottom > r.bottom) bottom = r.bottom;
        else if (bottom < r.top) bottom = r.top;
 
        if (right > r.right) right = r.right;
        else if (right < r.left) right = r.left;
    }
 
    void clip(T maxw, T maxh) {
        clip(ConcreteRect(0, 0, maxw, maxh));
    }
 
    void setEmpty() {
        left = right = top = bottom = 0;
    }
 
    bool isEmpty() const {
        return (left >= right || top >= bottom);
    }
 
    bool isValidRect() const {
        return (left <= right && top <= bottom);
    }
 
    void moveTo(T x, T y) {
        bottom += y - top;
        right += x - left;
        top = y;
        left = x;
    }
 
    void translate(T dx, T dy) {
        left += dx; right += dx;
        top += dy; bottom += dy;
    }
 
    void moveTo(const ConcretePoint &p) {
        moveTo(p.x, p.y);
    }
 
    bool constrain(const ConcreteRect &o) {
        return o.constrain(left, top, width(), height());
    }
 
    bool constrain(T &x, T &y, T w, T h) const {
        if (w > width() || h > height()) {
            return false;
        }
 
        if (x < left) {
            x = left;
        } else if (x > right - w) { // x + w > right
            x = right - w;
        }
        if (y < top) {
            y = top;
        } else if (y > bottom - h) { // y + h > bottom
            y = bottom - h;
        }
 
        return true;
    }
 
    void debugPrint(int debuglevel = 0, const char *caption = "Rect:") const {
        debug(debuglevel, "%s %d, %d, %d, %d", caption, left, top, right, bottom);
    }
 
    void debugPrintC(int debuglevel, uint32 debugChannel, const char *caption = "Rect:") const {
        debugC(debuglevel, debugChannel, "%s %d, %d, %d, %d", caption, left, top, right, bottom);
    }
 
    String toString() const {
        return String::format("%d, %d, %d, %d", left, top, right, bottom);
    }
 
    static ConcreteRect center(T cx, T cy, T w, T h) {
        T x = cx - w / 2, y = cy - h / 2;
        return ConcreteRect(x, y, x + w, y + h);
    }
 
    ConcretePoint center() const {
        return ConcretePoint((left + right) / 2, (bottom + top) / 2);
    }
 
    static bool getBlitRect(ConcretePoint &dst, ConcreteRect &rect, const ConcreteRect &clip) {
        if (dst.x < clip.left) {
            rect.left += clip.left - dst.x;
            dst.x = clip.left;
        }
 
        if (dst.y < clip.top) {
            rect.top += clip.top - dst.y;
            dst.y = clip.top;
        }
 
        int right = dst.x + rect.width();
        if (right > clip.right)
            rect.right -= right - clip.right;
 
        int bottom = dst.y + rect.height();
        if (bottom > clip.bottom)
            rect.bottom -= bottom - clip.bottom;
        return !rect.isEmpty();
    }
};
 
#define BEGIN_RECT_TYPE(T, Rect, Point) \
    struct Rect : public Common::RectBase<T, Rect, Point> {
 
#define END_RECT_TYPE(T, Rect, Point) \
        constexpr Rect() : RectBase() {} \
        constexpr Rect(T w, T h) : RectBase(w, h) {} \
        Rect(const Point &topLeft, const Point &bottomRight) : RectBase(topLeft, bottomRight) {} \
        constexpr Rect(const Point &topLeft, T w, T h) : RectBase(topLeft, w, h) {} \
        Rect(T x1, T y1, T x2, T y2) : RectBase(x1, y1, x2, y2) {} \
    };
 
BEGIN_RECT_TYPE(int16, Rect, Point)
END_RECT_TYPE(int16, Rect, Point)
BEGIN_RECT_TYPE(int32, Rect32, Point32)
END_RECT_TYPE(int32, Rect32, Point32)
} // End of namespace Common
 
#endif