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"

#define PRINT_RECT(x) (x).left,(x).top,(x).right,(x).bottom

namespace Common {

struct Point {
    int16 x;    
    int16 y;    
    constexpr Point() : x(0), y(0) {}

    constexpr Point(int16 x1, int16 y1) : x(x1), y(y1) {}
    bool  operator==(const Point &p)    const { return x == p.x && y == p.y; }
    bool  operator!=(const Point &p)    const { return x != p.x || y != p.y; }
    Point operator+(const Point &delta) const { return Point(x + delta.x, y + delta.y); }
    Point operator-(const Point &delta) const { return Point(x - delta.x, y - delta.y); }
    Point operator/(int divisor) const { return Point(x / divisor, y / divisor); }
    Point operator*(int multiplier) const { return Point(x * multiplier, y * multiplier); }
    Point operator/(double divisor) const { return Point((int16)(x / divisor), (int16)(y / divisor)); }
    Point operator*(double multiplier) const { return Point((int16)(x * multiplier), (int16)(y * multiplier)); }

    void operator+=(const Point &delta) {
        x += delta.x;
        y += delta.y;
    }

    void operator-=(const Point &delta) {
        x -= delta.x;
        y -= delta.y;
    }

    uint sqrDist(const Point &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);
    }
};

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((int16)(p.x * multiplier), (int16)(p.y * multiplier)); }

struct Rect {
    int16 top, left;        
    int16 bottom, right;    
    constexpr Rect() : top(0), left(0), bottom(0), right(0) {}
    constexpr Rect(int16 w, int16 h) : top(0), left(0), bottom(h), right(w) {}
    Rect(const Point &topLeft, const Point &bottomRight) : top(topLeft.y), left(topLeft.x), bottom(bottomRight.y), right(bottomRight.x) {
        assert(isValidRect());
    }
    constexpr Rect(const Point &topLeft, int16 w, int16 h) : top(topLeft.y), left(topLeft.x), bottom(topLeft.y + h), right(topLeft.x + w) {
    }
    Rect(int16 x1, int16 y1, int16 x2, int16 y2) : top(y1), left(x1), bottom(y2), right(x2) {
        assert(isValidRect());
    }
    bool operator==(const Rect &rhs) const { return equals(rhs); }
    bool operator!=(const Rect &rhs) const { return !equals(rhs); }

    Common::Point origin() const { return Common::Point(left, top); } 
    int16 width() const { return right - left; }                      
    int16 height() const { return bottom - top; }                     
    void setWidth(int16 aWidth) {   
        right = left + aWidth;
    }

    void setHeight(int16 aHeight) { 
        bottom = top + aHeight;
    }

    bool contains(int16 x, int16 y) const {
        return (left <= x) && (x < right) && (top <= y) && (y < bottom);
    }

    bool contains(const Point &p) const {
        return contains(p.x, p.y);
    }

    bool contains(const Rect &r) const {
        return (left <= r.left) && (r.right <= right) && (top <= r.top) && (r.bottom <= bottom);
    }

    bool equals(const Rect &r) const {
        return (left == r.left) && (right == r.right) && (top == r.top) && (bottom == r.bottom);
    }

    bool intersects(const Rect &r) const {
        return (left < r.right) && (r.left < right) && (top < r.bottom) && (r.top < bottom);
    }

    Rect findIntersectingRect(const Rect &r) const {
        if (!intersects(r))
            return Rect();

        return Rect(MAX(r.left, left), MAX(r.top, top), MIN(r.right, right), MIN(r.bottom, bottom));
    }

    void extend(const Rect &r) {
        left = MIN(left, r.left);
        right = MAX(right, r.right);
        top = MIN(top, r.top);
        bottom = MAX(bottom, r.bottom);
    }

    void grow(int16 offset) {
        top -= offset;
        left -= offset;
        bottom += offset;
        right += offset;
    }

    void clip(const Rect &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(int16 maxw, int16 maxh) {
        clip(Rect(0, 0, maxw, maxh));
    }

    bool isEmpty() const {
        return (left >= right || top >= bottom);
    }

    bool isValidRect() const {
        return (left <= right && top <= bottom);
    }

    void moveTo(int16 x, int16 y) {
        bottom += y - top;
        right += x - left;
        top = y;
        left = x;
    }

    void translate(int16 dx, int16 dy) {
        left += dx; right += dx;
        top += dy; bottom += dy;
    }

    void moveTo(const Point &p) {
        moveTo(p.x, p.y);
    }

    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);
    }

    static Rect center(int16 cx, int16 cy, int16 w, int16 h) {
        int x = cx - w / 2, y = cy - h / 2;
        return Rect(x, y, x + w, y + h);
    }

    static bool getBlitRect(Point &dst, Rect &rect, const Rect &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.right;
        if (right > clip.right)
            rect.right -= right - clip.right;

        int bottom = dst.y + rect.bottom;
        if (bottom > clip.bottom)
            rect.bottom -= bottom - clip.bottom;
        return !rect.isEmpty();
    }
};

} // End of namespace Common

#endif