Initial commit

engines/sci/graphics/helpers.h

@@ -0,0 +1,302 @@
+/* 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
+/**
+ * Multiplies a rectangle by two ratios with default
+ * rounding. Modifies the rect directly.
+ */
+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();
+}
+
+/**
+ * Multiplies a rectangle by two ratios with default
+ * rounding. Modifies the rect directly. Uses inclusive
+ * rectangle rounding.
+ */
+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;
+}
+
+/**
+ * Multiplies a number by a rational number, rounding up to
+ * the nearest whole number.
+ */
+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;
+}
+
+/**
+ * Multiplies a point by two rational numbers for X and Y,
+ * rounding up to the nearest whole number. Modifies the
+ * point directly.
+ */
+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);
+}
+
+/**
+ * Multiplies a point by two rational numbers for X and Y,
+ * rounding up to the nearest whole number. Modifies the
+ * rect directly.
+ */
+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;
+}
+
+/**
+ * Determines the parts of `r` that aren't overlapped by `other`.
+ * Returns -1 if `r` and `other` have no intersection.
+ * Returns number of returned parts (in `outRects`) otherwise.
+ * (In particular, this returns 0 if `r` is contained in `other`.)
+ */
+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