Initial commit

engines/mediastation/graphics.h

@@ -0,0 +1,269 @@
+/* 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 MEDIASTATION_GRAPHICS_H
+#define MEDIASTATION_GRAPHICS_H
+
+#include "common/rect.h"
+#include "common/array.h"
+#include "common/stack.h"
+#include "graphics/managed_surface.h"
+#include "graphics/screen.h"
+
+#include "mediastation/clients.h"
+#include "mediastation/mediascript/scriptvalue.h"
+
+namespace MediaStation {
+
+class MediaStationEngine;
+struct DissolvePattern;
+class Bitmap;
+
+enum BlitMode {
+	kUncompressedBlit = 0x00,
+	kRle8Blit = 0x01,
+	kClipEnabled = 0x04,
+	kUncompressedTransparentBlit = 0x08,
+	kPartialDissolve = 0x10,
+	kFullDissolve = 0x20,
+	kCccBlit = 0x40,
+	kCccTransparentBlit = 0x80
+};
+
+enum TransitionType {
+	kTransitionFadeToBlack = 300,
+	kTransitionFadeToPalette = 301,
+	kTransitionSetToPalette = 302,
+	kTransitionSetToBlack = 303,
+	kTransitionFadeToColor = 304,
+	kTransitionSetToColor = 305,
+	kTransitionSetToPercentOfPalette = 306,
+	kTransitionFadeToPaletteObject = 307,
+	kTransitionSetToPaletteObject = 308,
+	kTransitionSetToPercentOfPaletteObject = 309,
+	kTransitionColorShiftCurrentPalette = 310,
+	kTransitionCircleOut = 328
+};
+
+enum VideoDisplayManagerSectionType {
+	kVideoDisplayManagerUpdateDirty = 0x578,
+	kVideoDisplayManagerUpdateAll = 0x579,
+	kVideoDisplayManagerEffectTransition = 0x57a,
+	kVideoDisplayManagerSetTime = 0x57b,
+	kVideoDisplayManagerLoadPalette = 0x5aa,
+};
+
+class Region {
+public:
+	void addRect(const Common::Rect &rect);
+	bool intersects(const Common::Rect &rect);
+	void operator&=(const Common::Rect &rect);
+	void operator+=(const Common::Point &point);
+
+	Common::Array<Common::Rect> _rects;
+	Common::Rect _bounds;
+};
+
+class Clip {
+public:
+	Clip() {}
+	Clip(const Common::Rect &rect);
+
+	void addToRegion(const Region &region);
+	void addToRegion(const Common::Rect &rect);
+	bool clipIntersectsRect(const Common::Rect &rect);
+	void intersectWithRegion(const Common::Rect &rect);
+	void makeEmpty();
+
+	Region _region;
+	Common::Rect _bounds;
+};
+
+class DisplayContext {
+public:
+	bool clipIsEmpty();
+	void intersectClipWith(const Common::Rect &rect);
+	bool rectIsInClip(const Common::Rect &rect);
+	void setClipTo(Region region);
+	void emptyCurrentClip();
+
+	void addClip();
+	Clip *currentClip();
+	Clip *previousClip();
+	void verifyClipSize();
+
+	// These are not named as such in the original, but are helper functions
+	// for things that likely were macros or something similar in the original.
+	void pushOrigin();
+	void popOrigin();
+
+	Common::Point _origin;
+	Graphics::ManagedSurface *_destImage = nullptr;
+
+private:
+	Common::Stack<Common::Point> _origins;
+	Common::Stack<Clip> _clips;
+};
+
+class VideoDisplayManager : public ParameterClient {
+public:
+	VideoDisplayManager(MediaStationEngine *vm);
+	~VideoDisplayManager();
+
+	virtual bool attemptToReadFromStream(Chunk &chunk, uint sectionType) override;
+
+	void updateScreen() { _screen->update(); }
+	Graphics::Palette *getRegisteredPalette() { return _registeredPalette; }
+	void setRegisteredPalette(Graphics::Palette *palette) { _registeredPalette = palette; }
+
+	void imageBlit(
+		Common::Point destinationPoint,
+		const Bitmap *image,
+		double dissolveFactor,
+		DisplayContext *displayContext,
+		Graphics::ManagedSurface *destinationImage = nullptr);
+
+	void imageDeltaBlit(
+		Common::Point deltaFramePos,
+		const Common::Point &keyFrameOffset,
+		const Bitmap *deltaFrame,
+		const Bitmap *keyFrame,
+		const double dissolveFactor,
+		DisplayContext *displayContext);
+
+	void effectTransition(Common::Array<ScriptValue> &args);
+	void setTransitionOnSync(Common::Array<ScriptValue> &args) { _scheduledTransitionOnSync = args; }
+	void doTransitionOnSync();
+
+	void performUpdateDirty();
+	void performUpdateAll();
+
+	void setGammaValues(double red, double green, double blue);
+	void getDefaultGammaValues(double &red, double &green, double &blue);
+	void getGammaValues(double &red, double &green, double &blue);
+
+	DisplayContext _displayContext;
+
+private:
+	MediaStationEngine *_vm = nullptr;
+	Graphics::Screen *_screen = nullptr;
+	Graphics::Palette *_registeredPalette = nullptr;
+	Common::Array<ScriptValue> _scheduledTransitionOnSync;
+	double _defaultTransitionTime = 0.0;
+
+	const double DEFAULT_GAMMA_VALUE = 1.0;
+	double _redGamma = 1.0;
+	double _greenGamma = 1.0;
+	double _blueGamma = 1.0;
+
+	void readAndEffectTransition(Chunk &chunk);
+	void readAndRegisterPalette(Chunk &chunk);
+
+	// Blitting methods.
+	// blitRectsClip encompasses the functionality of both opaqueBlitRectsClip
+	// and transparentBlitRectsClip in the disasm.
+	void blitRectsClip(
+		Graphics::ManagedSurface *dest,
+		const Common::Point &destLocation,
+		const Graphics::ManagedSurface &source,
+		const Common::Array<Common::Rect> &dirtyRegion);
+	void rleBlitRectsClip(
+		Graphics::ManagedSurface *dest,
+		const Common::Point &destLocation,
+		const Bitmap *source,
+		const Common::Array<Common::Rect> &dirtyRegion);
+	Graphics::ManagedSurface decompressRle8Bitmap(
+		const Bitmap *source,
+		const Graphics::ManagedSurface *keyFrame = nullptr,
+		const Common::Point *keyFrameOffset = nullptr);
+	void dissolveBlitRectsClip(
+		Graphics::ManagedSurface *dest,
+		const Common::Point &destPos,
+		const Bitmap *source,
+		const Common::Array<Common::Rect> &dirtyRegion,
+		const uint dissolveFactor);
+	void dissolveBlit1Rect(
+		Graphics::ManagedSurface *dest,
+		const Common::Rect &areaToRedraw,
+		const Common::Point &originOnScreen,
+		const Bitmap *source,
+		const Common::Rect &dirtyRegion,
+		const DissolvePattern &pattern);
+	void fullDeltaRleBlitRectsClip(
+		Graphics::ManagedSurface *destinationImage,
+		const Common::Point &deltaFramePos,
+		const Common::Point &keyFrameOffset,
+		const Bitmap *deltaFrame,
+		const Bitmap *keyFrame,
+		const Common::Array<Common::Rect> &dirtyRegion);
+	void deltaRleBlitRectsClip(
+		Graphics::ManagedSurface *destinationImage,
+		const Common::Point &deltaFramePos,
+		const Bitmap *deltaFrame,
+		const Bitmap *keyFrame,
+		const Common::Array<Common::Rect> &dirtyRegion);
+	void deltaRleBlit1Rect(
+		Graphics::ManagedSurface *destinationImage,
+		const Common::Point &destinationPoint,
+		const Bitmap *sourceImage,
+		const Bitmap *deltaImage,
+		const Common::Rect &dirtyRect);
+
+	// Transition methods.
+	const double DEFAULT_FADE_TRANSITION_TIME_IN_SECONDS = 0.5;
+	const byte DEFAULT_PALETTE_TRANSITION_START_INDEX = 0x01;
+	const byte DEFAULT_PALETTE_TRANSITION_COLOR_COUNT = 0xFE;
+	void fadeToBlack(Common::Array<ScriptValue> &args);
+	void fadeToRegisteredPalette(Common::Array<ScriptValue> &args);
+	void setToRegisteredPalette(Common::Array<ScriptValue> &args);
+	void setToBlack(Common::Array<ScriptValue> &args);
+	void fadeToColor(Common::Array<ScriptValue> &args);
+	void setToColor(Common::Array<ScriptValue> &args);
+	void setToPercentOfPalette(Common::Array<ScriptValue> &args);
+	void fadeToPaletteObject(Common::Array<ScriptValue> &args);
+	void setToPaletteObject(Common::Array<ScriptValue> &args);
+	void setToPercentOfPaletteObject(Common::Array<ScriptValue> &args);
+	void colorShiftCurrentPalette(Common::Array<ScriptValue> &args);
+	void circleOut(Common::Array<ScriptValue> &args);
+
+	void _setPalette(Graphics::Palette &palette, uint startIndex, uint colorCount);
+	void _setPaletteToColor(Graphics::Palette &targetPalette, byte r, byte g, byte b);
+	uint _limitColorRange(uint &startIndex, uint &colorCount);
+	byte _interpolateColorComponent(byte source, byte target, double progress);
+
+	void _fadeToColor(byte r, byte g, byte b, double fadeTime, uint startIndex, uint colorCount);
+	void _setToColor(byte r, byte g, byte b, uint startIndex, uint colorCount);
+	void _setPercentToColor(double percent, byte r, byte g, byte b, uint startIndex, uint colorCount);
+
+	void _fadeToPalette(double fadeTime, Graphics::Palette &targetPalette, uint startIndex, uint colorCount);
+	void _setToPercentPalette(double percent, Graphics::Palette &currentPalette, Graphics::Palette &targetPalette,
+		uint startIndex, uint colorCount);
+	void _fadeToRegisteredPalette(double fadeTime, uint startIndex, uint colorCount);
+	void _setToRegisteredPalette(uint startIndex, uint colorCount);
+	void _colorShiftCurrentPalette(uint startIndex, uint shiftAmount, uint colorCount);
+	void _fadeToPaletteObject(uint paletteId, double fadeTime, uint startIndex, uint colorCount);
+	void _setToPaletteObject(uint paletteId, uint startIndex, uint colorCount);
+	void _setPercentToPaletteObject(double percent, uint paletteId, uint startIndex, uint colorCount);
+};
+
+} // End of namespace MediaStation
+
+#endif