SCI32: Move GfxRemap32 to separate files

11 files changed, 416 insertions, 367 deletions

diff --git a/engines/sci/engine/kgraphics32.cpp b/engines/sci/engine/kgraphics32.cpp
index 80e8d4ae0b..e85d2a9877 100644
--- a/engines/sci/engine/kgraphics32.cpp
+++ b/engines/sci/engine/kgraphics32.cpp
@@ -54,6 +54,7 @@
 #include "sci/graphics/frameout.h"
 #include "sci/graphics/paint32.h"
 #include "sci/graphics/palette32.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/text32.h"
 #endif
 
diff --git a/engines/sci/graphics/celobj32.cpp b/engines/sci/graphics/celobj32.cpp
index 3018c6b1c5..6559bba6d7 100644
--- a/engines/sci/graphics/celobj32.cpp
+++ b/engines/sci/graphics/celobj32.cpp
@@ -26,10 +26,8 @@
 #include "sci/graphics/celobj32.h"
 #include "sci/graphics/frameout.h"
 #include "sci/graphics/palette32.h"
-#include "sci/graphics/picture.h"
-#include "sci/graphics/remap.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/text32.h"
-#include "sci/graphics/view.h"
 
 namespace Sci {
 #pragma mark CelScaler
diff --git a/engines/sci/graphics/frameout.cpp b/engines/sci/graphics/frameout.cpp
index 5771ab59ff..9d3ab0463e 100644
--- a/engines/sci/graphics/frameout.cpp
+++ b/engines/sci/graphics/frameout.cpp
@@ -42,15 +42,13 @@
 #include "sci/graphics/coordadjuster.h"
 #include "sci/graphics/compare.h"
 #include "sci/graphics/font.h"
-#include "sci/graphics/view.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/paint32.h"
 #include "sci/graphics/palette32.h"
-#include "sci/graphics/picture.h"
-#include "sci/graphics/remap.h"
-#include "sci/graphics/text32.h"
 #include "sci/graphics/plane32.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/screen_item32.h"
+#include "sci/graphics/text32.h"
 #include "sci/graphics/frameout.h"
 #include "sci/video/robot_decoder.h"
 
diff --git a/engines/sci/graphics/palette32.cpp b/engines/sci/graphics/palette32.cpp
index 6844011675..6c6234d10d 100644
--- a/engines/sci/graphics/palette32.cpp
+++ b/engines/sci/graphics/palette32.cpp
@@ -28,7 +28,7 @@
 #include "sci/event.h"
 #include "sci/resource.h"
 #include "sci/graphics/palette32.h"
-#include "sci/graphics/remap.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/screen.h"
 
 namespace Sci {
diff --git a/engines/sci/graphics/plane32.cpp b/engines/sci/graphics/plane32.cpp
index 6f5ad424fd..175875c414 100644
--- a/engines/sci/graphics/plane32.cpp
+++ b/engines/sci/graphics/plane32.cpp
@@ -27,7 +27,7 @@
 #include "sci/graphics/frameout.h"
 #include "sci/graphics/lists32.h"
 #include "sci/graphics/plane32.h"
-#include "sci/graphics/remap.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/screen.h"
 #include "sci/graphics/screen_item32.h"
 
diff --git a/engines/sci/graphics/remap.cpp b/engines/sci/graphics/remap.cpp
index ff49e52f13..7f5721b742 100644
--- a/engines/sci/graphics/remap.cpp
+++ b/engines/sci/graphics/remap.cpp
@@ -104,277 +104,4 @@ void GfxRemap::updateRemapping() {
 		}
 	}
 }
-
-#pragma mark -
-#pragma mark SCI32 remapping
-
-#ifdef ENABLE_SCI32
-
-GfxRemap32::GfxRemap32(GfxPalette32 *palette) : _palette(palette) {
-	for (int i = 0; i < REMAP_COLOR_COUNT; i++)
-		_remaps[i] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
-	_noMapStart = _noMapCount = 0;
-	_update = false;
-	_remapCount = 0;
-
-	// The remap range was 245 - 254 in SCI2, but was changed to 235 - 244 in SCI21 middle.
-	// All versions of KQ7 are using the older remap range semantics.
-	_remapEndColor = (getSciVersion() >= SCI_VERSION_2_1_MIDDLE || g_sci->getGameId() == GID_KQ7) ? 244 : 254;
-}
-
-void GfxRemap32::remapOff(byte color) {
-	if (!color) {
-		for (int i = 0; i < REMAP_COLOR_COUNT; i++)
-			_remaps[i] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
-
-		_remapCount = 0;
-	} else {
-		assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-		const byte index = _remapEndColor - color;
-		_remaps[index] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
-		_remapCount--;
-	}
-
-	_update = true;
-}
-
-void GfxRemap32::setRemappingRange(byte color, byte from, byte to, byte base) {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	_remaps[_remapEndColor - color] = RemapParams(from, to, base, 0, 100, kRemappingByRange);
-	initColorArrays(_remapEndColor - color);
-	_remapCount++;
-	_update = true;
-}
-
-void GfxRemap32::setRemappingPercent(byte color, byte percent) {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, 0, percent, kRemappingByPercent);
-	initColorArrays(_remapEndColor - color);
-	_remapCount++;
-	_update = true;
-}
-
-void GfxRemap32::setRemappingToGray(byte color, byte gray) {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, gray, 100, kRemappingToGray);
-	initColorArrays(_remapEndColor - color);
-	_remapCount++;
-	_update = true;
-}
-
-void GfxRemap32::setRemappingToPercentGray(byte color, byte gray, byte percent) {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, gray, percent, kRemappingToPercentGray);
-	initColorArrays(_remapEndColor - color);
-	_remapCount++;
-	_update = true;
-}
-
-void GfxRemap32::setNoMatchRange(byte from, byte count) {
-	_noMapStart = from;
-	_noMapCount = count;
-}
-
-bool GfxRemap32::remapEnabled(byte color) const {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	const byte index = _remapEndColor - color;
-	return (_remaps[index].type != kRemappingNone);
-}
-
-byte GfxRemap32::remapColor(byte color, byte target) {
-	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
-	const byte index = _remapEndColor - color;
-	if (_remaps[index].type != kRemappingNone)
-		return _remaps[index].remap[target];
-	else
-		return target;
-}
-
-void GfxRemap32::initColorArrays(byte index) {
-	Palette *curPalette = &_palette->_sysPalette;
-	RemapParams *curRemap = &_remaps[index];
-
-	memcpy(curRemap->curColor, curPalette->colors, NON_REMAPPED_COLOR_COUNT * sizeof(Color));
-	memcpy(curRemap->targetColor, curPalette->colors, NON_REMAPPED_COLOR_COUNT * sizeof(Color));
-}
-
-bool GfxRemap32::updateRemap(byte index, bool palChanged) {
-	int result;
-	RemapParams *curRemap = &_remaps[index];
-	const Palette *curPalette = &_palette->_sysPalette;
-	const Palette *nextPalette = _palette->getNextPalette();
-	bool changed = false;
-
-	if (!_update && !palChanged)
-		return false;
-
-	Common::fill(_targetChanged, _targetChanged + NON_REMAPPED_COLOR_COUNT, false);
-
-	switch (curRemap->type) {
-	case kRemappingNone:
-		return false;
-	case kRemappingByRange:
-		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)  {
-			if (curRemap->from <= i && i <= curRemap->to)
-				result = i + curRemap->base;
-			else
-				result = i;
-
-			if (curRemap->remap[i] != result) {
-				changed = true;
-				curRemap->remap[i] = result;
-			}
-
-			curRemap->colorChanged[i] = true;
-		}
-		return changed;
-	case kRemappingByPercent:
-		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
-			// NOTE: This method uses nextPalette instead of curPalette
-			Color color = nextPalette->colors[i];
-
-			if (curRemap->curColor[i] != color) {
-				curRemap->colorChanged[i] = true;
-				curRemap->curColor[i] = color;
-			}
-
-			if (curRemap->percent != curRemap->oldPercent || curRemap->colorChanged[i])  {
-				byte red = CLIP<byte>(color.r * curRemap->percent / 100, 0, 255);
-				byte green = CLIP<byte>(color.g * curRemap->percent / 100, 0, 255);
-				byte blue = CLIP<byte>(color.b * curRemap->percent / 100, 0, 255);
-				byte used = curRemap->targetColor[i].used;
-
-				Color newColor = { used, red, green, blue };
-				if (curRemap->targetColor[i] != newColor)  {
-					_targetChanged[i] = true;
-					curRemap->targetColor[i] = newColor;
-				}
-			}
-		}
-		
-		changed = applyRemap(index);
-		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
-		curRemap->oldPercent = curRemap->percent;
-		return changed;
-	case kRemappingToGray:
-		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
-			Color color = curPalette->colors[i];
-
-			if (curRemap->curColor[i] != color) {
-				curRemap->colorChanged[i] = true;
-				curRemap->curColor[i] = color;
-			}
-
-			if (curRemap->gray != curRemap->oldGray || curRemap->colorChanged[i])  {
-				byte lumosity = ((color.r * 77) + (color.g * 151) + (color.b * 28)) >> 8;
-				byte red = CLIP<byte>(color.r - ((color.r - lumosity) * curRemap->gray / 100), 0, 255);
-				byte green = CLIP<byte>(color.g - ((color.g - lumosity) * curRemap->gray / 100), 0, 255);
-				byte blue = CLIP<byte>(color.b - ((color.b - lumosity) * curRemap->gray / 100), 0, 255);
-				byte used = curRemap->targetColor[i].used;
-
-				Color newColor = { used, red, green, blue };
-				if (curRemap->targetColor[i] != newColor)  {
-					_targetChanged[i] = true;
-					curRemap->targetColor[i] = newColor;
-				}
-			}
-		}
-
-		changed = applyRemap(index);
-		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
-		curRemap->oldGray = curRemap->gray;
-		return changed;
-	case kRemappingToPercentGray:
-		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
-			Color color = curPalette->colors[i];
-
-			if (curRemap->curColor[i] != color) {
-				curRemap->colorChanged[i] = true;
-				curRemap->curColor[i] = color;
-			}
-
-			if (curRemap->percent != curRemap->oldPercent || curRemap->gray != curRemap->oldGray || curRemap->colorChanged[i])  {
-				byte lumosity = ((color.r * 77) + (color.g * 151) + (color.b * 28)) >> 8;
-				lumosity = lumosity * curRemap->percent / 100;
-				byte red = CLIP<byte>(color.r - ((color.r - lumosity) * curRemap->gray / 100), 0, 255);
-				byte green = CLIP<byte>(color.g - ((color.g - lumosity) * curRemap->gray / 100), 0, 255);
-				byte blue = CLIP<byte>(color.b - ((color.b - lumosity) * curRemap->gray / 100), 0, 255);
-				byte used = curRemap->targetColor[i].used;
-
-				Color newColor = { used, red, green, blue };
-				if (curRemap->targetColor[i] != newColor)  {
-					_targetChanged[i] = true;
-					curRemap->targetColor[i] = newColor;
-				}
-			}
-		}
-
-		changed = applyRemap(index);
-		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
-		curRemap->oldPercent = curRemap->percent;
-		curRemap->oldGray = curRemap->gray;
-		return changed;
-	default:
-		return false;
-	}
-}
-
-static int colorDistance(Color a, Color b) {
-	int rDiff = (a.r - b.r) * (a.r - b.r);
-	int gDiff = (a.g - b.g) * (a.g - b.g);
-	int bDiff = (a.b - b.b) * (a.b - b.b);
-	return rDiff + gDiff + bDiff;
-}
-
-bool GfxRemap32::applyRemap(byte index) {
-	RemapParams *curRemap = &_remaps[index];
-	const bool *cycleMap = _palette->getCyclemap();
-	bool unmappedColors[NON_REMAPPED_COLOR_COUNT];
-	bool changed = false;
-
-	Common::fill(unmappedColors, unmappedColors + NON_REMAPPED_COLOR_COUNT, false);
-	if (_noMapCount)
-		Common::fill(unmappedColors + _noMapStart, unmappedColors + _noMapStart + _noMapCount, true);
-
-	for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)  {
-		if (cycleMap[i])
-			unmappedColors[i] = true;
-	}
-
-	for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++)  {
-		Color targetColor = curRemap->targetColor[i];
-		bool colorChanged = curRemap->colorChanged[curRemap->remap[i]];
-
-		if (!_targetChanged[i] && !colorChanged)
-			continue;
-
-		if (_targetChanged[i] && colorChanged)
-			if (curRemap->distance[i] < 100 && colorDistance(targetColor, curRemap->curColor[curRemap->remap[i]]) <= curRemap->distance[i])
-				continue;
-
-		int diff = 0;
-		int16 result = _palette->matchColor(targetColor.r, targetColor.g, targetColor.b, curRemap->distance[i], diff, unmappedColors);
-		if (result != -1 && curRemap->remap[i] != result)  {
-			changed = true;
-			curRemap->remap[i] = result;
-			curRemap->distance[i] = diff;
-		}
-	}
-
-	return changed;
-}
-
-bool GfxRemap32::remapAllTables(bool palChanged) {
-	bool changed = false;
-
-	for (int i = 0; i < REMAP_COLOR_COUNT; i++) {
-		changed |= updateRemap(i, palChanged);
-	}
-
-	_update = false;
-	return changed;
-}
-
-#endif
-
 } // End of namespace Sci
diff --git a/engines/sci/graphics/remap.h b/engines/sci/graphics/remap.h
index d012568f7f..d758a97ab0 100644
--- a/engines/sci/graphics/remap.h
+++ b/engines/sci/graphics/remap.h
@@ -38,9 +38,6 @@ enum ColorRemappingType {
 	kRemappingToPercentGray = 4
 };
 
-#define REMAP_COLOR_COUNT 9
-#define NON_REMAPPED_COLOR_COUNT 236
-
 /**
  * Remap class, handles color remapping
  */
@@ -68,87 +65,6 @@ private:
 	byte _remappingByRange[256];
 	uint16 _remappingPercentToSet;
 };
-
-#ifdef ENABLE_SCI32
-
-struct RemapParams {
-	byte from;
-	byte to;
-	byte base;
-	byte gray;
-	byte oldGray;
-	byte percent;
-	byte oldPercent;
-	ColorRemappingType type;
-	Color curColor[256];
-	Color targetColor[256];
-	byte distance[256];
-	byte remap[256];
-	bool colorChanged[256];
-
-	RemapParams() {
-		from = to = base = gray = oldGray = percent = oldPercent = 0;
-		type = kRemappingNone;
-
-		// curColor and targetColor are initialized in GfxRemap32::initColorArrays
-		memset(curColor, 0, 256 * sizeof(Color));
-		memset(targetColor, 0, 256 * sizeof(Color));
-		memset(distance, 0, 256);
-		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)
-			remap[i] = i;
-		Common::fill(colorChanged, colorChanged + ARRAYSIZE(colorChanged), true);
-	}
-
-	RemapParams(byte from_, byte to_, byte base_, byte gray_, byte percent_, ColorRemappingType type_) {
-		from = from_;
-		to = to_;
-		base = base_;
-		gray = oldGray = gray_;
-		percent = oldPercent = percent_;
-		type = type_;
-
-		// curColor and targetColor are initialized in GfxRemap32::initColorArrays
-		memset(curColor, 0, 256 * sizeof(Color));
-		memset(targetColor, 0, 256 * sizeof(Color));
-		memset(distance, 0, 256);
-		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)
-			remap[i] = i;
-		Common::fill(colorChanged, colorChanged + ARRAYSIZE(colorChanged), true);
-	}
-};
-
-class GfxRemap32 {
-public:
-	GfxRemap32(GfxPalette32 *palette);
-	~GfxRemap32() {}
-
-	void remapOff(byte color);
-	void setRemappingRange(byte color, byte from, byte to, byte base);
-	void setRemappingPercent(byte color, byte percent);
-	void setRemappingToGray(byte color, byte gray);
-	void setRemappingToPercentGray(byte color, byte gray, byte percent);
-	void setNoMatchRange(byte from, byte count);
-	bool remapEnabled(byte color) const;
-	byte remapColor(byte color, byte target);
-	bool remapAllTables(bool palChanged);
-	int getRemapCount() const { return _remapCount; }
-	int getStartColor() const { return _remapEndColor - REMAP_COLOR_COUNT + 1; }
-	int getEndColor() const { return _remapEndColor; }
-private:
-	GfxPalette32 *_palette;
-	RemapParams _remaps[REMAP_COLOR_COUNT];
-	bool _update;
-	byte _noMapStart, _noMapCount;
-	bool _targetChanged[NON_REMAPPED_COLOR_COUNT];
-	byte _remapEndColor;
-	int _remapCount;
-
-	void initColorArrays(byte index);
-	bool applyRemap(byte index);
-	bool updateRemap(byte index, bool palChanged);
-};
-#endif
-
 } // End of namespace Sci
 
 #endif
diff --git a/engines/sci/graphics/remap32.cpp b/engines/sci/graphics/remap32.cpp
new file mode 100644
index 0000000000..5516d0e271
--- /dev/null
+++ b/engines/sci/graphics/remap32.cpp
@@ -0,0 +1,294 @@
+/* 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/graphics/palette32.h"
+#include "sci/graphics/remap32.h"
+
+namespace Sci {
+
+GfxRemap32::GfxRemap32(GfxPalette32 *palette) : _palette(palette) {
+	for (int i = 0; i < REMAP_COLOR_COUNT; i++)
+		_remaps[i] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
+	_noMapStart = _noMapCount = 0;
+	_update = false;
+	_remapCount = 0;
+
+	// The remap range was 245 - 254 in SCI2, but was changed to 235 - 244 in SCI21 middle.
+	// All versions of KQ7 are using the older remap range semantics.
+	_remapEndColor = (getSciVersion() >= SCI_VERSION_2_1_MIDDLE || g_sci->getGameId() == GID_KQ7) ? 244 : 254;
+}
+
+void GfxRemap32::remapOff(byte color) {
+	if (!color) {
+		for (int i = 0; i < REMAP_COLOR_COUNT; i++)
+			_remaps[i] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
+
+		_remapCount = 0;
+	} else {
+		assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+		const byte index = _remapEndColor - color;
+		_remaps[index] = RemapParams(0, 0, 0, 0, 100, kRemappingNone);
+		_remapCount--;
+	}
+
+	_update = true;
+}
+
+void GfxRemap32::setRemappingRange(byte color, byte from, byte to, byte base) {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	_remaps[_remapEndColor - color] = RemapParams(from, to, base, 0, 100, kRemappingByRange);
+	initColorArrays(_remapEndColor - color);
+	_remapCount++;
+	_update = true;
+}
+
+void GfxRemap32::setRemappingPercent(byte color, byte percent) {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, 0, percent, kRemappingByPercent);
+	initColorArrays(_remapEndColor - color);
+	_remapCount++;
+	_update = true;
+}
+
+void GfxRemap32::setRemappingToGray(byte color, byte gray) {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, gray, 100, kRemappingToGray);
+	initColorArrays(_remapEndColor - color);
+	_remapCount++;
+	_update = true;
+}
+
+void GfxRemap32::setRemappingToPercentGray(byte color, byte gray, byte percent) {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	_remaps[_remapEndColor - color] = RemapParams(0, 0, 0, gray, percent, kRemappingToPercentGray);
+	initColorArrays(_remapEndColor - color);
+	_remapCount++;
+	_update = true;
+}
+
+void GfxRemap32::setNoMatchRange(byte from, byte count) {
+	_noMapStart = from;
+	_noMapCount = count;
+}
+
+bool GfxRemap32::remapEnabled(byte color) const {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	const byte index = _remapEndColor - color;
+	return (_remaps[index].type != kRemappingNone);
+}
+
+byte GfxRemap32::remapColor(byte color, byte target) {
+	assert(_remapEndColor - color >= 0 && _remapEndColor - color < REMAP_COLOR_COUNT);
+	const byte index = _remapEndColor - color;
+	if (_remaps[index].type != kRemappingNone)
+		return _remaps[index].remap[target];
+	else
+		return target;
+}
+
+void GfxRemap32::initColorArrays(byte index) {
+	Palette *curPalette = &_palette->_sysPalette;
+	RemapParams *curRemap = &_remaps[index];
+
+	memcpy(curRemap->curColor, curPalette->colors, NON_REMAPPED_COLOR_COUNT * sizeof(Color));
+	memcpy(curRemap->targetColor, curPalette->colors, NON_REMAPPED_COLOR_COUNT * sizeof(Color));
+}
+
+bool GfxRemap32::updateRemap(byte index, bool palChanged) {
+	int result;
+	RemapParams *curRemap = &_remaps[index];
+	const Palette *curPalette = &_palette->_sysPalette;
+	const Palette *nextPalette = _palette->getNextPalette();
+	bool changed = false;
+
+	if (!_update && !palChanged)
+		return false;
+
+	Common::fill(_targetChanged, _targetChanged + NON_REMAPPED_COLOR_COUNT, false);
+
+	switch (curRemap->type) {
+	case kRemappingNone:
+		return false;
+	case kRemappingByRange:
+		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)  {
+			if (curRemap->from <= i && i <= curRemap->to)
+				result = i + curRemap->base;
+			else
+				result = i;
+
+			if (curRemap->remap[i] != result) {
+				changed = true;
+				curRemap->remap[i] = result;
+			}
+
+			curRemap->colorChanged[i] = true;
+		}
+		return changed;
+	case kRemappingByPercent:
+		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
+			// NOTE: This method uses nextPalette instead of curPalette
+			Color color = nextPalette->colors[i];
+
+			if (curRemap->curColor[i] != color) {
+				curRemap->colorChanged[i] = true;
+				curRemap->curColor[i] = color;
+			}
+
+			if (curRemap->percent != curRemap->oldPercent || curRemap->colorChanged[i])  {
+				byte red = CLIP<byte>(color.r * curRemap->percent / 100, 0, 255);
+				byte green = CLIP<byte>(color.g * curRemap->percent / 100, 0, 255);
+				byte blue = CLIP<byte>(color.b * curRemap->percent / 100, 0, 255);
+				byte used = curRemap->targetColor[i].used;
+
+				Color newColor = { used, red, green, blue };
+				if (curRemap->targetColor[i] != newColor)  {
+					_targetChanged[i] = true;
+					curRemap->targetColor[i] = newColor;
+				}
+			}
+		}
+		
+		changed = applyRemap(index);
+		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
+		curRemap->oldPercent = curRemap->percent;
+		return changed;
+	case kRemappingToGray:
+		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
+			Color color = curPalette->colors[i];
+
+			if (curRemap->curColor[i] != color) {
+				curRemap->colorChanged[i] = true;
+				curRemap->curColor[i] = color;
+			}
+
+			if (curRemap->gray != curRemap->oldGray || curRemap->colorChanged[i])  {
+				byte lumosity = ((color.r * 77) + (color.g * 151) + (color.b * 28)) >> 8;
+				byte red = CLIP<byte>(color.r - ((color.r - lumosity) * curRemap->gray / 100), 0, 255);
+				byte green = CLIP<byte>(color.g - ((color.g - lumosity) * curRemap->gray / 100), 0, 255);
+				byte blue = CLIP<byte>(color.b - ((color.b - lumosity) * curRemap->gray / 100), 0, 255);
+				byte used = curRemap->targetColor[i].used;
+
+				Color newColor = { used, red, green, blue };
+				if (curRemap->targetColor[i] != newColor)  {
+					_targetChanged[i] = true;
+					curRemap->targetColor[i] = newColor;
+				}
+			}
+		}
+
+		changed = applyRemap(index);
+		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
+		curRemap->oldGray = curRemap->gray;
+		return changed;
+	case kRemappingToPercentGray:
+		for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++) {
+			Color color = curPalette->colors[i];
+
+			if (curRemap->curColor[i] != color) {
+				curRemap->colorChanged[i] = true;
+				curRemap->curColor[i] = color;
+			}
+
+			if (curRemap->percent != curRemap->oldPercent || curRemap->gray != curRemap->oldGray || curRemap->colorChanged[i])  {
+				byte lumosity = ((color.r * 77) + (color.g * 151) + (color.b * 28)) >> 8;
+				lumosity = lumosity * curRemap->percent / 100;
+				byte red = CLIP<byte>(color.r - ((color.r - lumosity) * curRemap->gray / 100), 0, 255);
+				byte green = CLIP<byte>(color.g - ((color.g - lumosity) * curRemap->gray / 100), 0, 255);
+				byte blue = CLIP<byte>(color.b - ((color.b - lumosity) * curRemap->gray / 100), 0, 255);
+				byte used = curRemap->targetColor[i].used;
+
+				Color newColor = { used, red, green, blue };
+				if (curRemap->targetColor[i] != newColor)  {
+					_targetChanged[i] = true;
+					curRemap->targetColor[i] = newColor;
+				}
+			}
+		}
+
+		changed = applyRemap(index);
+		Common::fill(curRemap->colorChanged, curRemap->colorChanged + NON_REMAPPED_COLOR_COUNT, false);
+		curRemap->oldPercent = curRemap->percent;
+		curRemap->oldGray = curRemap->gray;
+		return changed;
+	default:
+		return false;
+	}
+}
+
+static int colorDistance(Color a, Color b) {
+	int rDiff = (a.r - b.r) * (a.r - b.r);
+	int gDiff = (a.g - b.g) * (a.g - b.g);
+	int bDiff = (a.b - b.b) * (a.b - b.b);
+	return rDiff + gDiff + bDiff;
+}
+
+bool GfxRemap32::applyRemap(byte index) {
+	RemapParams *curRemap = &_remaps[index];
+	const bool *cycleMap = _palette->getCyclemap();
+	bool unmappedColors[NON_REMAPPED_COLOR_COUNT];
+	bool changed = false;
+
+	Common::fill(unmappedColors, unmappedColors + NON_REMAPPED_COLOR_COUNT, false);
+	if (_noMapCount)
+		Common::fill(unmappedColors + _noMapStart, unmappedColors + _noMapStart + _noMapCount, true);
+
+	for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)  {
+		if (cycleMap[i])
+			unmappedColors[i] = true;
+	}
+
+	for (int i = 1; i < NON_REMAPPED_COLOR_COUNT; i++)  {
+		Color targetColor = curRemap->targetColor[i];
+		bool colorChanged = curRemap->colorChanged[curRemap->remap[i]];
+
+		if (!_targetChanged[i] && !colorChanged)
+			continue;
+
+		if (_targetChanged[i] && colorChanged)
+			if (curRemap->distance[i] < 100 && colorDistance(targetColor, curRemap->curColor[curRemap->remap[i]]) <= curRemap->distance[i])
+				continue;
+
+		int diff = 0;
+		int16 result = _palette->matchColor(targetColor.r, targetColor.g, targetColor.b, curRemap->distance[i], diff, unmappedColors);
+		if (result != -1 && curRemap->remap[i] != result)  {
+			changed = true;
+			curRemap->remap[i] = result;
+			curRemap->distance[i] = diff;
+		}
+	}
+
+	return changed;
+}
+
+bool GfxRemap32::remapAllTables(bool palChanged) {
+	bool changed = false;
+
+	for (int i = 0; i < REMAP_COLOR_COUNT; i++) {
+		changed |= updateRemap(i, palChanged);
+	}
+
+	_update = false;
+	return changed;
+}
+
+} // End of namespace Sci
diff --git a/engines/sci/graphics/remap32.h b/engines/sci/graphics/remap32.h
new file mode 100644
index 0000000000..ff871f62f3
--- /dev/null
+++ b/engines/sci/graphics/remap32.h
@@ -0,0 +1,113 @@
+/* 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_REMAP32_H
+#define SCI_GRAPHICS_REMAP32_H
+
+#include "common/array.h"
+#include "sci/graphics/remap.h"
+
+namespace Sci {
+
+#define REMAP_COLOR_COUNT 9
+#define NON_REMAPPED_COLOR_COUNT 236
+
+struct RemapParams {
+	byte from;
+	byte to;
+	byte base;
+	byte gray;
+	byte oldGray;
+	byte percent;
+	byte oldPercent;
+	ColorRemappingType type;
+	Color curColor[256];
+	Color targetColor[256];
+	byte distance[256];
+	byte remap[256];
+	bool colorChanged[256];
+
+	RemapParams() {
+		from = to = base = gray = oldGray = percent = oldPercent = 0;
+		type = kRemappingNone;
+
+		// curColor and targetColor are initialized in GfxRemap32::initColorArrays
+		memset(curColor, 0, 256 * sizeof(Color));
+		memset(targetColor, 0, 256 * sizeof(Color));
+		memset(distance, 0, 256);
+		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)
+			remap[i] = i;
+		Common::fill(colorChanged, colorChanged + ARRAYSIZE(colorChanged), true);
+	}
+
+	RemapParams(byte from_, byte to_, byte base_, byte gray_, byte percent_, ColorRemappingType type_) {
+		from = from_;
+		to = to_;
+		base = base_;
+		gray = oldGray = gray_;
+		percent = oldPercent = percent_;
+		type = type_;
+
+		// curColor and targetColor are initialized in GfxRemap32::initColorArrays
+		memset(curColor, 0, 256 * sizeof(Color));
+		memset(targetColor, 0, 256 * sizeof(Color));
+		memset(distance, 0, 256);
+		for (int i = 0; i < NON_REMAPPED_COLOR_COUNT; i++)
+			remap[i] = i;
+		Common::fill(colorChanged, colorChanged + ARRAYSIZE(colorChanged), true);
+	}
+};
+
+class GfxRemap32 {
+public:
+	GfxRemap32(GfxPalette32 *palette);
+	~GfxRemap32() {}
+
+	void remapOff(byte color);
+	void setRemappingRange(byte color, byte from, byte to, byte base);
+	void setRemappingPercent(byte color, byte percent);
+	void setRemappingToGray(byte color, byte gray);
+	void setRemappingToPercentGray(byte color, byte gray, byte percent);
+	void setNoMatchRange(byte from, byte count);
+	bool remapEnabled(byte color) const;
+	byte remapColor(byte color, byte target);
+	bool remapAllTables(bool palChanged);
+	int getRemapCount() const { return _remapCount; }
+	int getStartColor() const { return _remapEndColor - REMAP_COLOR_COUNT + 1; }
+	int getEndColor() const { return _remapEndColor; }
+private:
+	GfxPalette32 *_palette;
+	RemapParams _remaps[REMAP_COLOR_COUNT];
+	bool _update;
+	byte _noMapStart, _noMapCount;
+	bool _targetChanged[NON_REMAPPED_COLOR_COUNT];
+	byte _remapEndColor;
+	int _remapCount;
+
+	void initColorArrays(byte index);
+	bool applyRemap(byte index);
+	bool updateRemap(byte index, bool palChanged);
+};
+
+} // End of namespace Sci
+
+#endif
diff --git a/engines/sci/module.mk b/engines/sci/module.mk
index ba6c853075..5d54e2a52c 100644
--- a/engines/sci/module.mk
+++ b/engines/sci/module.mk
@@ -88,6 +88,7 @@ MODULE_OBJS += \
 	graphics/paint32.o \
 	graphics/plane32.o \
 	graphics/palette32.o \
+	graphics/remap32.o \
 	graphics/screen_item32.o \
 	graphics/text32.o \
 	sound/audio32.o \
diff --git a/engines/sci/sci.cpp b/engines/sci/sci.cpp
index b80456c09c..243c12b5cf 100644
--- a/engines/sci/sci.cpp
+++ b/engines/sci/sci.cpp
@@ -65,9 +65,10 @@
 
 #ifdef ENABLE_SCI32
 #include "sci/graphics/controls32.h"
+#include "sci/graphics/frameout.h"
 #include "sci/graphics/palette32.h"
+#include "sci/graphics/remap32.h"
 #include "sci/graphics/text32.h"
-#include "sci/graphics/frameout.h"
 #include "sci/sound/audio32.h"
 #include "sci/video/robot_decoder.h"
 #endif