helpers.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 SCI_GRAPHICS_HELPERS_H
#define SCI_GRAPHICS_HELPERS_H

#include "common/endian.h"  // for READ_LE_UINT16
#include "common/rect.h"
#include "common/serializer.h"
#ifdef ENABLE_SCI32
#include "common/rational.h"
#include "graphics/pixelformat.h"
#include "graphics/surface.h"
#endif
#include "sci/detection.h"
#include "sci/engine/vm_types.h"
#include "sci/graphics/helpers_detection_enums.h" // for enum ViewType

namespace Sci {

// Cache limits
#define MAX_CACHED_CURSORS 10
#define MAX_CACHED_FONTS 20
#define MAX_CACHED_VIEWS 50

enum ShakeDirection {
    kShakeVertical   = 1,
    kShakeHorizontal = 2
};

typedef int GuiResourceId; // is a resource-number and -1 means no parameter given

typedef int16 TextAlignment;

#define PORTS_FIRSTWINDOWID 2
#define PORTS_FIRSTSCRIPTWINDOWID 3

struct Port {
    uint16 id;
    int16 top, left;
    Common::Rect rect;
    int16 curTop, curLeft;
    int16 fontHeight;
    GuiResourceId fontId;
    bool greyedOutput;
    int16 penClr, backClr;
    int16 penMode;
    uint16 counterTillFree;

    Port(uint16 theId) : id(theId), top(0), left(0),
        curTop(0), curLeft(0),
        fontHeight(0), fontId(0), greyedOutput(false),
        penClr(0), backClr(0xFF), penMode(0), counterTillFree(0) {
    }
    virtual ~Port() {}

    bool isWindow() const { return id >= PORTS_FIRSTWINDOWID && id != 0xFFFF; }
};

struct Window : public Port, public Common::Serializable {
    Common::Rect dims; // client area of window
    Common::Rect restoreRect; // total area of window including borders
    uint16 wndStyle;
    uint16 saveScreenMask;
    reg_t hSaved1;
    reg_t hSaved2;
    Common::String title;
    bool bDrawn;

    Window(uint16 theId) : Port(theId),
        wndStyle(0), saveScreenMask(0),
        hSaved1(NULL_REG), hSaved2(NULL_REG),
        bDrawn(false) {
    }

    void syncRect(Common::Serializer &ser, Common::Rect &targetRect) {
        ser.syncAsSint16LE(targetRect.top);
        ser.syncAsSint16LE(targetRect.left);
        ser.syncAsSint16LE(targetRect.bottom);
        ser.syncAsSint16LE(targetRect.right);
    }

    void saveLoadWithSerializer(Common::Serializer &ser) override {
        ser.syncAsUint16LE(id);
        ser.syncAsSint16LE(top);
        ser.syncAsSint16LE(left);
        syncRect(ser, rect);
        ser.syncAsSint16LE(curTop);
        ser.syncAsSint16LE(curLeft);
        ser.syncAsSint16LE(fontHeight);
        ser.syncAsSint32LE(fontId);
        ser.syncAsByte(greyedOutput);
        ser.syncAsSint16LE(penClr);
        ser.syncAsSint16LE(backClr);
        ser.syncAsSint16LE(penMode);
        ser.syncAsUint16LE(counterTillFree);
        syncRect(ser, dims);
        syncRect(ser, restoreRect);
        ser.syncAsUint16LE(wndStyle);
        ser.syncAsUint16LE(saveScreenMask);
        if (ser.isLoading()) {
            // The hunk table isn't saved, so we just set both pointers to NULL
            hSaved1 = NULL_REG;
            hSaved2 = NULL_REG;
        }
        ser.syncString(title);
        ser.syncAsByte(bDrawn);
    }
};

#ifdef ENABLE_SCI32

inline void mul(Common::Rect &rect, const Common::Rational &ratioX, const Common::Rational &ratioY) {
    rect.left = (rect.left * ratioX).toInt();
    rect.top = (rect.top * ratioY).toInt();
    rect.right = (rect.right * ratioX).toInt();
    rect.bottom = (rect.bottom * ratioY).toInt();
}

inline void mulinc(Common::Rect &rect, const Common::Rational &ratioX, const Common::Rational &ratioY) {
    rect.left = (rect.left * ratioX).toInt();
    rect.top = (rect.top * ratioY).toInt();
    rect.right = ((rect.right - 1) * ratioX).toInt() + 1;
    rect.bottom = ((rect.bottom - 1) * ratioY).toInt() + 1;
}

inline int mulru(const int value, const Common::Rational &ratio, const int extra = 0) {
    int num = (value + extra) * ratio.getNumerator();
    int result = num / ratio.getDenominator();
    if (num > ratio.getDenominator() && num % ratio.getDenominator()) {
        ++result;
    }
    return result - extra;
}

inline void mulru(Common::Point &point, const Common::Rational &ratioX, const Common::Rational &ratioY) {
    point.x = mulru(point.x, ratioX);
    point.y = mulru(point.y, ratioY);
}

inline void mulru(Common::Rect &rect, const Common::Rational &ratioX, const Common::Rational &ratioY, const int extra) {
    rect.left = mulru(rect.left, ratioX);
    rect.top = mulru(rect.top, ratioY);
    rect.right = mulru(rect.right - 1, ratioX, extra) + 1;
    rect.bottom = mulru(rect.bottom - 1, ratioY, extra) + 1;
}

inline int splitRects(Common::Rect r, const Common::Rect &other, Common::Rect(&outRects)[4]) {
    if (!r.intersects(other)) {
        return -1;
    }

    int splitCount = 0;
    if (r.top < other.top) {
        Common::Rect &t = outRects[splitCount++];
        t = r;
        t.bottom = other.top;
        r.top = other.top;
    }

    if (r.bottom > other.bottom) {
        Common::Rect &t = outRects[splitCount++];
        t = r;
        t.top = other.bottom;
        r.bottom = other.bottom;
    }

    if (r.left < other.left) {
        Common::Rect &t = outRects[splitCount++];
        t = r;
        t.right = other.left;
        r.left = other.left;
    }

    if (r.right > other.right) {
        Common::Rect &t = outRects[splitCount++];
        t = r;
        t.left = other.right;
    }

    return splitCount;
}

typedef Graphics::Surface Buffer;
#endif

struct Color {
    byte used;
    byte r, g, b;

#ifdef ENABLE_SCI32
    bool operator==(const Color &other) const {
        return used == other.used && r == other.r && g == other.g && b == other.b;
    }
    inline bool operator!=(const Color &other) const {
        return !operator==(other);
    }
#endif
};

struct Palette {
    byte mapping[256];
    uint32 timestamp;
    Color colors[256];
    byte intensity[256];

#ifdef ENABLE_SCI32
    bool operator==(const Palette &other) const {
        for (int i = 0; i < ARRAYSIZE(colors); ++i) {
            if (colors[i] != other.colors[i]) {
                return false;
            }
        }

        return true;
    }
    inline bool operator!=(const Palette &other) const {
        return !(*this == other);
    }
#endif
};

struct PaletteMod {
    int8 r, g, b;
};

struct PicMod {
    uint16 id;
    byte multiplier;
};

struct ViewMod {
    uint16 id;
    int16 loop;
    int16 cel;
    byte multiplier;
};

struct SciFxMod {
    SciGameId gameId;
    const PaletteMod *paletteMods;
    const int paletteModsSize;
    const PicMod *picMods;
    const int picModsSize;
    const ViewMod *viewMods;
    const int viewModsSize;
};

struct PalSchedule {
    byte from;
    uint32 schedule;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_HELPERS_H