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 ULTIMA8_MISC_RECT_H
#define ULTIMA8_MISC_RECT_H

namespace Ultima {
namespace Ultima8 {

// TODO: Replace Ultima8::Rect with Common::Rect
// The key difference between Ultima8::Rect and Common::Rect is the use of int32 for variables.
// Attempts to change this may cause the game to be unstable.

struct Rect {
    int32 left, top;
    int32 right, bottom;

    Rect() : top(0), left(0), bottom(0), right(0) {}
    Rect(int x1, int y1, int x2, int y2) : top(y1), left(x1), bottom(y2), right(x2) {}

    bool operator==(const Rect &rhs) const { return equals(rhs); }
    bool operator!=(const Rect &rhs) const { return !equals(rhs); }

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

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

    // Check if the rectangle is empty (its width or length is 0) or invalid (its width or length are negative).
    bool isEmpty() const {
        return (left >= right || top >= bottom);
    }

    // Check to see if a Rectangle is 'valid'
    bool isValidRect() const {
        return (left <= right && top <= bottom);
    }

    // Check to see if a point is within the Rectangle
    bool contains(int16 x, int16 y) const {
        return (left <= x) && (x < right) && (top <= y) && (y < bottom);
    }

    // Check if the given Rect is contained inside this rectangle.
    bool contains(const Rect &r) const {
        return (left <= r.left) && (r.right <= right) && (top <= r.top) && (r.bottom <= bottom);
    }

    // Move the Rect (Relative)
    void translate(int32 dx, int32 dy) {
        left += dx;
        right += dx;
        top += dy;
        bottom += dy;
    }

    // Move the Rect (Absolute)
    void moveTo(int32 x, int32 y) {
        bottom += y - top;
        right += x - left;
        top = y;
        left = x;
    }

    void clip(const Rect &r) {
        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.top) bottom = r.top;
        else if (bottom > r.bottom) bottom = r.bottom;

        if (right < r.left) right = r.left;
        else if (right > r.right) right = r.right;
    }

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

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

};

} // End of namespace Ultima8
} // End of namespace Ultima

#endif