SCI: Split color remapping functionality into a separate class

Currently, only the SCI16 remapping functionality is implemented
(used in the QFG4 demo)

9 files changed, 243 insertions, 122 deletions

diff --git a/engines/sci/engine/kgraphics.cpp b/engines/sci/engine/kgraphics.cpp
index c0a3be4c11..93d0d91b65 100644
--- a/engines/sci/engine/kgraphics.cpp
+++ b/engines/sci/engine/kgraphics.cpp
@@ -45,6 +45,7 @@
 #include "sci/graphics/paint16.h"
 #include "sci/graphics/picture.h"
 #include "sci/graphics/ports.h"
+#include "sci/graphics/remap.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/text16.h"
 #include "sci/graphics/view.h"
@@ -1248,16 +1249,16 @@ reg_t kRemapColors(EngineState *s, int argc, reg_t *argv) {
 	switch (operation) {
 	case 0: { // remap by percent
 		uint16 percent = argv[1].toUint16();
-		g_sci->_gfxPalette16->resetRemapping();
-		g_sci->_gfxPalette16->setRemappingPercent(254, percent);
+		g_sci->_gfxRemap16->resetRemapping();
+		g_sci->_gfxRemap16->setRemappingPercent(254, percent);
 		}
 		break;
 	case 1:	{ // remap by range
 		uint16 from = argv[1].toUint16();
 		uint16 to = argv[2].toUint16();
 		uint16 base = argv[3].toUint16();
-		g_sci->_gfxPalette16->resetRemapping();
-		g_sci->_gfxPalette16->setRemappingRange(254, from, to, base);
+		g_sci->_gfxRemap16->resetRemapping();
+		g_sci->_gfxRemap16->setRemappingRange(254, from, to, base);
 		}
 		break;
 	case 2:	// turn remapping off (unused)
diff --git a/engines/sci/graphics/palette.cpp b/engines/sci/graphics/palette.cpp
index 6f6e0b672e..1514ad838f 100644
--- a/engines/sci/graphics/palette.cpp
+++ b/engines/sci/graphics/palette.cpp
@@ -32,6 +32,7 @@
 #include "sci/graphics/cache.h"
 #include "sci/graphics/maciconbar.h"
 #include "sci/graphics/palette.h"
+#include "sci/graphics/remap.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/view.h"
 
@@ -103,9 +104,6 @@ GfxPalette::GfxPalette(ResourceManager *resMan, GfxScreen *screen)
 	default:
 		error("GfxPalette: Unknown view type");
 	}
-
-	_remapOn = false;
-	resetRemapping();
 }
 
 GfxPalette::~GfxPalette() {
@@ -336,79 +334,6 @@ void GfxPalette::set(Palette *newPalette, bool force, bool forceRealMerge) {
 	}
 }
 
-byte GfxPalette::remapColor(byte remappedColor, byte screenColor) {
-	assert(_remapOn);
-	if (_remappingType[remappedColor] == kRemappingByRange)
-		return _remappingByRange[screenColor];
-	else if (_remappingType[remappedColor] == kRemappingByPercent)
-		return _remappingByPercent[screenColor];
-	else
-		error("remapColor(): Color %d isn't remapped", remappedColor);
-
-	return 0;	// should never reach here
-}
-
-void GfxPalette::resetRemapping() {
-	_remapOn = false;
-	_remappingPercentToSet = 0;
-
-	for (int i = 0; i < 256; i++) {
-		_remappingType[i] = kRemappingNone;
-		_remappingByPercent[i] = i;
-		_remappingByRange[i] = i;
-	}
-}
-
-void GfxPalette::setRemappingPercent(byte color, byte percent) {
-	_remapOn = true;
-
-	// We need to defer the setup of the remapping table every time the screen
-	// palette is changed, so that kernelFindColor() can find the correct
-	// colors. Set it once here, in case the palette stays the same and update
-	// it on each palette change by copySysPaletteToScreen().
-	_remappingPercentToSet = percent;
-
-	for (int i = 0; i < 256; i++) {
-		byte r = _sysPalette.colors[i].r * _remappingPercentToSet / 100;
-		byte g = _sysPalette.colors[i].g * _remappingPercentToSet / 100;
-		byte b = _sysPalette.colors[i].b * _remappingPercentToSet / 100;
-		_remappingByPercent[i] = kernelFindColor(r, g, b);
-	}
-
-	_remappingType[color] = kRemappingByPercent;
-}
-
-void GfxPalette::setRemappingPercentGray(byte color, byte percent) {
-	_remapOn = true;
-
-	// We need to defer the setup of the remapping table every time the screen
-	// palette is changed, so that kernelFindColor() can find the correct
-	// colors. Set it once here, in case the palette stays the same and update
-	// it on each palette change by copySysPaletteToScreen().
-	_remappingPercentToSet = percent;
-
-	// Note: This is not what the original does, but the results are the same visually
-	for (int i = 0; i < 256; i++) {
-		byte rComponent = (byte)(_sysPalette.colors[i].r * _remappingPercentToSet * 0.30 / 100);
-		byte gComponent = (byte)(_sysPalette.colors[i].g * _remappingPercentToSet * 0.59 / 100);
-		byte bComponent = (byte)(_sysPalette.colors[i].b * _remappingPercentToSet * 0.11 / 100);
-		byte luminosity = rComponent + gComponent + bComponent;
-		_remappingByPercent[i] = kernelFindColor(luminosity, luminosity, luminosity);
-	}
-
-	_remappingType[color] = kRemappingByPercent;
-}
-
-void GfxPalette::setRemappingRange(byte color, byte from, byte to, byte base) {
-	_remapOn = true;
-
-	for (int i = from; i <= to; i++) {
-		_remappingByRange[i] = i + base;
-	}
-
-	_remappingType[color] = kRemappingByRange;
-}
-
 bool GfxPalette::insert(Palette *newPalette, Palette *destPalette) {
 	bool paletteChanged = false;
 
@@ -589,15 +514,8 @@ void GfxPalette::copySysPaletteToScreen() {
 		}
 	}
 
-	// Check if we need to reset remapping by percent with the new colors.
-	if (_remappingPercentToSet) {
-		for (int i = 0; i < 256; i++) {
-			byte r = _sysPalette.colors[i].r * _remappingPercentToSet / 100;
-			byte g = _sysPalette.colors[i].g * _remappingPercentToSet / 100;
-			byte b = _sysPalette.colors[i].b * _remappingPercentToSet / 100;
-			_remappingByPercent[i] = kernelFindColor(r, g, b);
-		}
-	}
+	if (g_sci->_gfxRemap16)
+		g_sci->_gfxRemap16->updateRemapping();
 
 	g_system->getPaletteManager()->setPalette(bpal, 0, 256);
 }
diff --git a/engines/sci/graphics/palette.h b/engines/sci/graphics/palette.h
index 61a8d36cb9..7335dc59d0 100644
--- a/engines/sci/graphics/palette.h
+++ b/engines/sci/graphics/palette.h
@@ -35,12 +35,6 @@ class GfxScreen;
 #define SCI_PALETTE_MATCH_PERFECT 0x8000
 #define SCI_PALETTE_MATCH_COLORMASK 0xFF
 
-enum ColorRemappingType {
-	kRemappingNone = 0,
-	kRemappingByRange = 1,
-	kRemappingByPercent = 2
-};
-
 /**
  * Palette class, handles palette operations like changing intensity, setting up the palette, merging different palettes
  */
@@ -64,15 +58,6 @@ public:
 	void getSys(Palette *pal);
 	uint16 getTotalColorCount() const { return _totalScreenColors; }
 
-	void resetRemapping();
-	void setRemappingPercent(byte color, byte percent);
-	void setRemappingPercentGray(byte color, byte percent);
-	void setRemappingRange(byte color, byte from, byte to, byte base);
-	bool isRemapped(byte color) const {
-		return _remapOn && (_remappingType[color] != kRemappingNone);
-	}
-	byte remapColor(byte remappedColor, byte screenColor);
-
 	void setOnScreen();
 	void copySysPaletteToScreen();
 
@@ -138,12 +123,6 @@ protected:
 	int _palVarySignal;
 	uint16 _totalScreenColors;
 
-	bool _remapOn;
-	ColorRemappingType _remappingType[256];
-	byte _remappingByPercent[256];
-	byte _remappingByRange[256];
-	uint16 _remappingPercentToSet;
-
 	void loadMacIconBarPalette();
 	byte *_macClut;
 };
diff --git a/engines/sci/graphics/remap.cpp b/engines/sci/graphics/remap.cpp
new file mode 100644
index 0000000000..1f1ae4da0e
--- /dev/null
+++ b/engines/sci/graphics/remap.cpp
@@ -0,0 +1,134 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "sci/sci.h"
+#include "sci/resource.h"
+#include "sci/graphics/palette.h"
+#include "sci/graphics/remap.h"
+#include "sci/graphics/screen.h"
+
+namespace Sci {
+
+#pragma mark -
+#pragma mark SCI16 remapping (QFG4 demo)
+
+GfxRemap::GfxRemap(GfxScreen *screen, GfxPalette *palette)
+	: _screen(screen), _palette(palette) {
+	_remapOn = false;
+	resetRemapping();
+}
+
+GfxRemap::~GfxRemap() {
+}
+
+byte GfxRemap::remapColor(byte remappedColor, byte screenColor) {
+	assert(_remapOn);
+	if (_remappingType[remappedColor] == kRemappingByRange)
+		return _remappingByRange[screenColor];
+	else if (_remappingType[remappedColor] == kRemappingByPercent)
+		return _remappingByPercent[screenColor];
+	else
+		error("remapColor(): Color %d isn't remapped", remappedColor);
+
+	return 0;	// should never reach here
+}
+
+void GfxRemap::resetRemapping() {
+	_remapOn = false;
+	_remappingPercentToSet = 0;
+
+	for (int i = 0; i < 256; i++) {
+		_remappingType[i] = kRemappingNone;
+		_remappingByPercent[i] = i;
+		_remappingByRange[i] = i;
+	}
+}
+
+void GfxRemap::setRemappingPercent(byte color, byte percent) {
+	_remapOn = true;
+
+	// We need to defer the setup of the remapping table every time the screen
+	// palette is changed, so that kernelFindColor() can find the correct
+	// colors. Set it once here, in case the palette stays the same and update
+	// it on each palette change by copySysPaletteToScreen().
+	_remappingPercentToSet = percent;
+
+	for (int i = 0; i < 256; i++) {
+		byte r = _palette->_sysPalette.colors[i].r * _remappingPercentToSet / 100;
+		byte g = _palette->_sysPalette.colors[i].g * _remappingPercentToSet / 100;
+		byte b = _palette->_sysPalette.colors[i].b * _remappingPercentToSet / 100;
+		_remappingByPercent[i] = _palette->kernelFindColor(r, g, b);
+	}
+
+	_remappingType[color] = kRemappingByPercent;
+}
+
+void GfxRemap::setRemappingRange(byte color, byte from, byte to, byte base) {
+	_remapOn = true;
+
+	for (int i = from; i <= to; i++) {
+		_remappingByRange[i] = i + base;
+	}
+
+	_remappingType[color] = kRemappingByRange;
+}
+
+void GfxRemap::updateRemapping() {
+	// Check if we need to reset remapping by percent with the new colors.
+	if (_remappingPercentToSet) {
+		for (int i = 0; i < 256; i++) {
+			byte r = _palette->_sysPalette.colors[i].r * _remappingPercentToSet / 100;
+			byte g = _palette->_sysPalette.colors[i].g * _remappingPercentToSet / 100;
+			byte b = _palette->_sysPalette.colors[i].b * _remappingPercentToSet / 100;
+			_remappingByPercent[i] = _palette->kernelFindColor(r, g, b);
+		}
+	}
+}
+
+#pragma mark -
+#pragma mark SCI32 remapping
+
+#if 0
+// TODO
+void GfxRemap32::setRemappingPercentGray(byte color, byte percent) {
+	_remapOn = true;
+
+	// We need to defer the setup of the remapping table every time the screen
+	// palette is changed, so that kernelFindColor() can find the correct
+	// colors. Set it once here, in case the palette stays the same and update
+	// it on each palette change by copySysPaletteToScreen().
+	_remappingPercentToSet = percent;
+
+	// Note: This is not what the original does, but the results are the same visually
+	for (int i = 0; i < 256; i++) {
+		byte rComponent = (byte)(_sysPalette.colors[i].r * _remappingPercentToSet * 0.30 / 100);
+		byte gComponent = (byte)(_sysPalette.colors[i].g * _remappingPercentToSet * 0.59 / 100);
+		byte bComponent = (byte)(_sysPalette.colors[i].b * _remappingPercentToSet * 0.11 / 100);
+		byte luminosity = rComponent + gComponent + bComponent;
+		_remappingByPercent[i] = kernelFindColor(luminosity, luminosity, luminosity);
+	}
+
+	_remappingType[color] = kRemappingByPercent;
+}
+#endif
+
+} // End of namespace Sci
diff --git a/engines/sci/graphics/remap.h b/engines/sci/graphics/remap.h
new file mode 100644
index 0000000000..e92eaffad2
--- /dev/null
+++ b/engines/sci/graphics/remap.h
@@ -0,0 +1,77 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SCI_GRAPHICS_REMAP_H
+#define SCI_GRAPHICS_REMAP_H
+
+#include "common/array.h"
+#include "sci/graphics/helpers.h"
+
+namespace Sci {
+
+class GfxScreen;
+
+enum ColorRemappingType {
+	kRemappingNone = 0,
+	kRemappingByRange = 1,
+	kRemappingByPercent = 2
+};
+
+/**
+ * Remap class, handles color remapping
+ */
+class GfxRemap {
+public:
+	GfxRemap(GfxScreen *screen, GfxPalette *_palette);
+	~GfxRemap();
+	void resetRemapping();
+	void setRemappingPercent(byte color, byte percent);
+	void setRemappingRange(byte color, byte from, byte to, byte base);
+	bool isRemapped(byte color) const {
+		return _remapOn && (_remappingType[color] != kRemappingNone);
+	}
+	byte remapColor(byte remappedColor, byte screenColor);
+	void updateRemapping();
+
+private:
+	GfxScreen *_screen;
+	GfxPalette *_palette;
+
+	bool _remapOn;
+	ColorRemappingType _remappingType[256];
+	byte _remappingByPercent[256];
+	byte _remappingByRange[256];
+	uint16 _remappingPercentToSet;
+};
+
+#ifdef ENABLE_SCI32
+class GfxRemap32 {
+public:
+	GfxRemap32(GfxScreen *screen, GfxPalette *_palette) {}
+	~GfxRemap32() {}
+	//void setRemappingPercentGray(byte color, byte percent);
+};
+#endif
+
+} // End of namespace Sci
+
+#endif
diff --git a/engines/sci/graphics/view.cpp b/engines/sci/graphics/view.cpp
index 4116eda876..ff3fc70619 100644
--- a/engines/sci/graphics/view.cpp
+++ b/engines/sci/graphics/view.cpp
@@ -25,6 +25,7 @@
 #include "sci/engine/state.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/palette.h"
+#include "sci/graphics/remap.h"
 #include "sci/graphics/coordadjuster.h"
 #include "sci/graphics/view.h"
 
@@ -842,12 +843,11 @@ void GfxView::draw(const Common::Rect &rect, const Common::Rect &clipRect, const
 					const int y2 = clipRectTranslated.top + y;
 					if (!upscaledHires) {
 						if (priority >= _screen->getPriority(x2, y2)) {
-							if (!_palette->isRemapped(palette->mapping[color])) {
-								_screen->putPixel(x2, y2, drawMask, palette->mapping[color], priority, 0);
-							} else {
-								byte remappedColor = _palette->remapColor(palette->mapping[color], _screen->getVisual(x2, y2));
-								_screen->putPixel(x2, y2, drawMask, remappedColor, priority, 0);
-							}
+							byte outputColor = palette->mapping[color];
+							// SCI16 remapping (QFG4 demo)
+							if (g_sci->_gfxRemap16 && g_sci->_gfxRemap16->isRemapped(outputColor))
+								outputColor = g_sci->_gfxRemap16->remapColor(outputColor, _screen->getVisual(x2, y2));
+							_screen->putPixel(x2, y2, drawMask, outputColor, priority, 0);
 						}
 					} else {
 						// UpscaledHires means view is hires and is supposed to
@@ -957,12 +957,11 @@ void GfxView::drawScaled(const Common::Rect &rect, const Common::Rect &clipRect,
 			const int x2 = clipRectTranslated.left + x;
 			const int y2 = clipRectTranslated.top + y;
 			if (color != clearKey && priority >= _screen->getPriority(x2, y2)) {
-				if (!_palette->isRemapped(palette->mapping[color])) {
-					_screen->putPixel(x2, y2, drawMask, palette->mapping[color], priority, 0);
-				} else {
-					byte remappedColor = _palette->remapColor(palette->mapping[color], _screen->getVisual(x2, y2));
-					_screen->putPixel(x2, y2, drawMask, remappedColor, priority, 0);
-				}
+				byte outputColor = palette->mapping[color];
+				// SCI16 remapping (QFG4 demo)
+				if (g_sci->_gfxRemap16 && g_sci->_gfxRemap16->isRemapped(outputColor))
+					outputColor = g_sci->_gfxRemap16->remapColor(outputColor, _screen->getVisual(x2, y2));
+				_screen->putPixel(x2, y2, drawMask, outputColor, priority, 0);
 			}
 		}
 	}
diff --git a/engines/sci/module.mk b/engines/sci/module.mk
index 963b65742d..a02147e4d0 100644
--- a/engines/sci/module.mk
+++ b/engines/sci/module.mk
@@ -57,6 +57,7 @@ MODULE_OBJS := \
 	graphics/picture.o \
 	graphics/portrait.o \
 	graphics/ports.o \
+	graphics/remap.o \
 	graphics/screen.o \
 	graphics/text16.o \
 	graphics/transitions.o \
diff --git a/engines/sci/sci.cpp b/engines/sci/sci.cpp
index 1221c303ec..6bc6650245 100644
--- a/engines/sci/sci.cpp
+++ b/engines/sci/sci.cpp
@@ -58,6 +58,7 @@
 #include "sci/graphics/picture.h"
 #include "sci/graphics/ports.h"
 #include "sci/graphics/palette.h"
+#include "sci/graphics/remap.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/text16.h"
 #include "sci/graphics/transitions.h"
@@ -163,6 +164,7 @@ SciEngine::~SciEngine() {
 	delete _gfxText32;
 	delete _robotDecoder;
 	delete _gfxFrameout;
+	delete _gfxRemap32;
 #endif
 	delete _gfxMenu;
 	delete _gfxControls16;
@@ -175,6 +177,7 @@ SciEngine::~SciEngine() {
 	delete _gfxPorts;
 	delete _gfxCache;
 	delete _gfxPalette16;
+	delete _gfxRemap16;
 	delete _gfxCursor;
 	delete _gfxScreen;
 
@@ -660,6 +663,7 @@ void SciEngine::initGraphics() {
 	_gfxPaint = 0;
 	_gfxPaint16 = 0;
 	_gfxPalette16 = 0;
+	_gfxRemap16 = 0;
 	_gfxPorts = 0;
 	_gfxText16 = 0;
 	_gfxTransitions = 0;
@@ -670,6 +674,7 @@ void SciEngine::initGraphics() {
 	_gfxFrameout = 0;
 	_gfxPaint32 = 0;
 	_gfxPalette32 = 0;
+	_gfxRemap32 = 0;
 #endif
 
 	if (hasMacIconBar())
@@ -679,9 +684,12 @@ void SciEngine::initGraphics() {
 	if (getSciVersion() >= SCI_VERSION_2) {
 		_gfxPalette32 = new GfxPalette32(_resMan, _gfxScreen);
 		_gfxPalette16 = _gfxPalette32;
+		_gfxRemap32 = new GfxRemap32(_gfxScreen, _gfxPalette32);
 	} else {
 #endif
 		_gfxPalette16 = new GfxPalette(_resMan, _gfxScreen);
+		if (getGameId() == GID_QFG4DEMO)
+			_gfxRemap16 = new GfxRemap(_gfxScreen, _gfxPalette16);
 #ifdef ENABLE_SCI32
 	}
 #endif
diff --git a/engines/sci/sci.h b/engines/sci/sci.h
index 1f3b4b2d58..2474db81d9 100644
--- a/engines/sci/sci.h
+++ b/engines/sci/sci.h
@@ -71,6 +71,8 @@ class GfxPaint16;
 class GfxPaint32;
 class GfxPalette;
 class GfxPalette32;
+class GfxRemap;
+class GfxRemap32;
 class GfxPorts;
 class GfxScreen;
 class GfxText16;
@@ -352,6 +354,8 @@ public:
 	GfxMenu *_gfxMenu; // Menu for 16-bit gfx
 	GfxPalette *_gfxPalette16;
 	GfxPalette32 *_gfxPalette32; // Palette for 32-bit gfx
+	GfxRemap *_gfxRemap16;	// Remapping for the QFG4 demo
+	GfxRemap32 *_gfxRemap32; // Remapping for 32-bit gfx
 	GfxPaint *_gfxPaint;
 	GfxPaint16 *_gfxPaint16; // Painting in 16-bit gfx
 	GfxPaint32 *_gfxPaint32; // Painting in 32-bit gfx