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/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_RECT_H
#define SAGA2_RECT_H

#include "common/memstream.h"

namespace Saga2 {

struct StaticPoint16 {
    int16 x, y;

    void set(int16 nx, int16 ny) {
        x = nx;
        y = ny;
    }
};

class Point16 {
public:
    int16               x, y;

    // constructors
    Point16() { x = y = 0; }
    Point16(int16 nx, int16 ny) {
        x = nx;
        y = ny;
    }

    Point16(StaticPoint16 p) {
        x = p.x;
        y = p.y;
    }

    void load(Common::SeekableReadStream *stream);
    void write(Common::MemoryWriteStreamDynamic *out);

    // Point16 operators
    friend Point16 operator+ (Point16 a, Point16 b) {
        return Point16(a.x + b.x, a.y + b.y);
    }

    friend Point16 operator- (Point16 a) {
        return Point16(-a.x, -a.y);
    }

    friend Point16 operator- (Point16 a, Point16 b) {
        return Point16(a.x - b.x, a.y - b.y);
    }

    friend Point16 operator* (Point16 a, int b) {
        return Point16(a.x * (int16)b, a.y * (int16)b);
    }

    friend Point16 operator/ (Point16 a, int b) {
        return Point16(a.x / (int16)b, a.y / (int16)b);
    }

    friend Point16 operator>>(Point16 a, int b) {
        return Point16(a.x >> (int16)b, a.y >> (int16)b);
    }

    friend Point16 operator<<(Point16 a, int b) {
        return Point16(a.x << (int16)b, a.y << (int16)b);
    }

    friend int     operator==(Point16 a, Point16 b) {
        return a.x == b.x && a.y == b.y;
    }

    friend int     operator!=(Point16 a, Point16 b) {
        return a.x != b.x || a.y != b.y;
    }

    void operator+= (Point16 a) {
        x += a.x;
        y += a.y;
    }
    void operator-= (Point16 a) {
        x -= a.x;
        y -= a.y;
    }
    void operator*= (int a)     {
        x *= (int16)a;
        y *= (int16)a;
    }
    void operator/= (int a)     {
        x /= (int16)a;
        y /= (int16)a;
    }
    void operator>>=(int a)     {
        x >>= (int16)a;
        y >>= (int16)a;
    }
    void operator<<=(int a)     {
        x <<= (int16)a;
        y <<= (int16)a;
    }

    void debugPrint(int level = 0, const char *msg = "Point32:") {
        debug(level, "%s %d,%d", msg, x, y);
    }
    // Point16 functions

};

typedef Point16         Vector16;           // vectors are treated as points

//  An Extent is like a rect, but with only size, not position.

typedef Point16         Extent16;               // contains width and height

/* ===================================================================== *
   Point32: 32-bit 2-D point
 * ===================================================================== */

struct StaticPoint32 {
    int32 x, y;

    void set(int16 nx, int16 ny) {
        x = nx;
        y = ny;
    }

    friend StaticPoint32 operator+ (StaticPoint32 a, StaticPoint32 b) {
        StaticPoint32 p;
        p.x = a.x + b.x;
        p.y = a.y + b.y;
        return p;
    }

    friend StaticPoint32 operator- (StaticPoint32 a, StaticPoint32 b) {
        StaticPoint32 p;
        p.x = a.x - b.x;
        p.y = a.y - b.y;
        return p;
    }

    friend StaticPoint32 operator*(StaticPoint32 a, int b) {
        StaticPoint32 p;
        p.x = a.x * b;
        p.y = a.y * b;

        return p;
    }

    friend StaticPoint32 operator/(StaticPoint32 a, int b) {
        StaticPoint32 p;
        p.x = a.x / b;
        p.y = a.y / b;

        return p;
    }

    void operator+= (StaticPoint32 a) {
        x += a.x;
        y += a.y;
    }
};

class Point32 {
public:
    int32               x, y;

    // constructors
    Point32() { x = y = 0; }
    Point32(int32 nx, int32 ny) {
        x = nx;
        y = ny;
    }

    //  Conversion operators
    Point32(Point16 p) {
        x = p.x;
        y = p.y;
    }
    operator Point16() {
        return Point16((int16)x, (int16)y);
    }

    Point32(StaticPoint32 p) {
        x = p.x;
        y = p.y;
    }

    // Point32 operators
    friend Point32 operator+ (Point32 a, Point32 b) {
        return Point32(a.x + b.x, a.y + b.y);
    }

    friend Point32 operator- (Point32 a) {
        return Point32(-a.x, -a.y);
    }

    friend Point32 operator- (Point32 a, Point32 b) {
        return Point32(a.x - b.x, a.y - b.y);
    }

    friend Point32 operator* (Point32 a, int b) {
        return Point32(a.x * (int32)b, a.y * (int32)b);
    }

    friend Point32 operator/ (Point32 a, int b) {
        return Point32(a.x / (int32)b, a.y / (int32)b);
    }

    friend Point32 operator>>(Point32 a, int b) {
        return Point32(a.x >> (int32)b, a.y >> (int32)b);
    }

    friend Point32 operator<<(Point32 a, int b) {
        return Point32(a.x << (int32)b, a.y << (int32)b);
    }

    friend int     operator==(Point32 a, Point32 b) {
        return a.x == b.x && a.y == b.y;
    }

    friend int     operator!=(Point32 a, Point32 b) {
        return a.x != b.x || a.y != b.y;
    }

    void operator+= (Point32 a) {
        x += a.x;
        y += a.y;
    }
    void operator-= (Point32 a) {
        x -= a.x;
        y -= a.y;
    }
    void operator*= (int a)     {
        x *= (int32)a;
        y *= (int32)a;
    }
    void operator/= (int a)     {
        x /= (int32)a;
        y /= (int32)a;
    }
    void operator>>=(int a)     {
        x >>= (int32)a;
        y >>= (int32)a;
    }
    void operator<<=(int a)     {
        x <<= (int32)a;
        y <<= (int32)a;
    }

    void debugPrint(int level = 0, const char *msg = "Point32:") {
        debug(level, "%s %d,%d", msg, x, y);
    }
};

typedef Point32         Vector32;           // vectors are treated as points

//  An Extent is like a rect, but with only size, not position.

typedef Point32         Extent32;               // contains width and height

struct StaticRect {
    int16 x, y, width, height;
};

/* ===================================================================== *
   Rect16: 16-bit 2-D rectangle
 * ===================================================================== */

class Rect16 {
public:
    int16               x, y,
                        width, height;

    // constructors
    Rect16() { x = y = width = height = 0; }
    Rect16(int16 nx, int16 ny, int16 nw, int16 nh) {
        x = nx;
        y = ny;
        width = nw;
        height = nh;
    }
    Rect16(Point16 a, int16 nw, int16 nh) {
        x = a.x;
        y = a.y;
        width = nw;
        height = nh;
    }
    Rect16(Point16 a, Point16 b) {
        x = a.x;
        y = a.y;
        width = (int16)(b.x - a.x);
        height = (int16)(b.y - a.y);
    }

    Rect16(StaticRect r) {
        x = r.x;
        y = r.y;
        width = r.width;
        height = r.height;
    }

    void read(Common::InSaveFile *in);
    void write(Common::MemoryWriteStreamDynamic *out);

    //  Rect16 operators

    friend int     operator==(Rect16 a, Rect16 b) {
        return  a.x == b.x
                && a.y == b.y
                && a.width == b.width
                && a.height == b.height;
    }

    friend int     operator!=(Rect16 a, Rect16 b) {
        return  a.x != b.x
                || a.y != b.y
                || a.width != b.width
                || a.height != b.height;
    }

    friend Rect16 operator+ (Rect16 a, Point16 b) {
        return Rect16(a.x + b.x, a.y + b.y, a.width, a.height);
    }

    friend Rect16 operator+ (Point16 b, Rect16 a) {
        return Rect16(a.x + b.x, a.y + b.y, a.width, a.height);
    }

    friend Rect16 operator- (Rect16 a, Point16 b) {
        return Rect16(a.x - b.x, a.y - b.y, a.width, a.height);
    }

    void operator+= (Point16 a) {
        x += a.x;
        y += a.y;
    }
    void operator-= (Point16 a) {
        x -= a.x;
        y -= a.y;
    }

    // functions
    void normalize();                        // make rect right-side out
    void expand(int16 dx, int16 dy);             // grow or shrink the rect
    void expand(int16 left, int16 top, int16 right, int16 bottom);

    int empty() const {
        return width <= 0 || height <= 0;
    }

    bool ptInside(int16 px, int16 py) const {         // true if point inside
        return px >= x && px < (x + width) && py >= y && py < (y + height);
    }
    bool ptInside(const Point16 p) const {
        return ptInside(p.x, p.y);
    }
    bool overlap(const Rect16 &r) const;
};

//  Intersect two rectangles

Rect16 intersect(const Rect16, const Rect16);
Rect16 bound(const Rect16, const Rect16);

/* ===================================================================== *
   Rect32: 16-bit 2-D rectangle
 * ===================================================================== */

class Rect32 {
public:
    int32               x, y,
                        width, height;

    // constructors
    Rect32() { x = y = width = height = 0; }
    Rect32(int32 nx, int32 ny, int32 nw, int32 nh) {
        x = nx;
        y = ny;
        width = nw;
        height = nh;
    }
    Rect32(Point16 a, int32 nw, int32 nh) {
        x = a.x;
        y = a.y;
        width = nw;
        height = nh;
    }
    Rect32(Point16 a, Point16 b) {
        x = a.x;
        y = a.y;
        width = (int32)(b.x - a.x);
        height = (int32)(b.y - a.y);
    }
    Rect32(Point32 a, int32 nw, int32 nh) {
        x = a.x;
        y = a.y;
        width = nw;
        height = nh;
    }
    Rect32(Point32 a, Point32 b) {
        x = a.x;
        y = a.y;
        width = (int32)(b.x - a.x);
        height = (int32)(b.y - a.y);
    }
    //  Conversion operators
    Rect32(Rect16 r) {
        x = r.x;
        y = r.y;
        width = r.width;
        height = r.height;
    }
    operator Rect16() {
        return Rect16((int16)x, (int16)y, (int16)width, (int16)height);
    }

    //  Rect32 operators

    friend int     operator==(Rect32 a, Rect32 b) {
        return  a.x == b.x
                && a.y == b.y
                && a.width == b.width
                && a.height == b.height;
    }

    friend int     operator!=(Rect32 a, Rect32 b) {
        return  a.x != b.x
                || a.y != b.y
                || a.width != b.width
                || a.height != b.height;
    }

    friend Rect32 operator+ (Rect32 a, Point16 b) {
        return Rect32(a.x + b.x, a.y + b.y, a.width, a.height);
    }

    friend Rect32 operator+ (Point16 b, Rect32 a) {
        return Rect32(a.x + b.x, a.y + b.y, a.width, a.height);
    }

    friend Rect32 operator- (Rect32 a, Point16 b) {
        return Rect32(a.x - b.x, a.y - b.y, a.width, a.height);
    }

    friend Rect32 operator+ (Point32 b, Rect32 a) {
        return Rect32(a.x + b.x, a.y + b.y, a.width, a.height);
    }

    friend Rect32 operator- (Rect32 a, Point32 b) {
        return Rect32(a.x - b.x, a.y - b.y, a.width, a.height);
    }

    void operator+= (Point16 a) {
        x += a.x;
        y += a.y;
    }
    void operator-= (Point16 a) {
        x -= a.x;
        y -= a.y;
    }

    void operator+= (Point32 a) {
        x += a.x;
        y += a.y;
    }
    void operator-= (Point32 a) {
        x -= a.x;
        y -= a.y;
    }
    // functions
    void normalize();                        // make rect right-side out

    void expand(int32 dx, int32 dy);             // grow or shrink the rect
    void expand(int32 left, int32 top, int32 right, int32 bottom);

    int empty() const {
        return width <= 0 || height <= 0;
    }

    bool ptInside(int32 px, int32 py) const {         // true if point inside
        return px >= x && px < (x + width) && py >= y && py < (y + height);
    }
    bool ptInside(const Point16 p) const {
        return ptInside(p.x, p.y);
    }

    bool overlap(const Rect32 &r) const;
};

//  Intersect two rectangles

Rect32 intersect(const Rect32, const Rect32);
Rect32 bound(const Rect32, const Rect32);

} // end of namespace Saga2

#endif