Add 16bit color support for later HE games.

svn-id: r41153

1 files changed, 160 insertions, 57 deletions

diff --git a/engines/scumm/he/palette_he.cpp b/engines/scumm/he/palette_he.cpp
index d055b77ee2..812c39d173 100644
--- a/engines/scumm/he/palette_he.cpp
+++ b/engines/scumm/he/palette_he.cpp
@@ -31,6 +31,27 @@
 
 namespace Scumm {
 
+uint8 *ScummEngine::getHEPaletteSlot(uint16 palSlot) {
+	assertRange(0, palSlot, _numPalettes, "palette");
+
+	if (_game.heversion >= 99) {
+		if (palSlot)
+			return _hePalettes + palSlot * _hePaletteSlot + 768;
+		else
+			return _hePalettes + _hePaletteSlot + 768;
+	}
+
+	return NULL;
+}
+
+uint16 ScummEngine::get16BitColor(uint8 r, uint8 g, uint8 b) {
+	uint16 ar = (r >> 3) << 10;
+	uint16 ag = (g >> 3) <<  5;
+	uint16 ab = (b >> 3) <<  0;
+	uint16 col = ar | ag | ab;
+	return col;
+}
+
 void ScummEngine_v71he::remapHEPalette(const uint8 *src, uint8 *dst) {
 	int r, g, b, sum, bestitem, bestsum;
 	int ar, ag, ab;
@@ -38,7 +59,7 @@ void ScummEngine_v71he::remapHEPalette(const uint8 *src, uint8 *dst) {
 	src += 30;
 
 	if (_game.heversion >= 99) {
-		palPtr = _hePalettes + 1024 + 30;
+		palPtr = _hePalettes + _hePaletteSlot + 30;
 	} else {
 		palPtr = _currentPalette + 30;
 	}
@@ -73,9 +94,9 @@ void ScummEngine_v71he::remapHEPalette(const uint8 *src, uint8 *dst) {
 uint8 *ScummEngine_v90he::getHEPaletteIndex(int palSlot) {
 	if (palSlot) {
 		assert(palSlot >= 1 && palSlot <= _numPalettes);
-		return _hePalettes + palSlot * 1024;
+		return _hePalettes + palSlot * _hePaletteSlot;
 	} else {
-		return _hePalettes + 1024;
+		return _hePalettes + _hePaletteSlot;
 	}
 }
 
@@ -84,7 +105,7 @@ int ScummEngine_v90he::getHEPaletteSimilarColor(int palSlot, int red, int green,
 	assertRange(0, start, 255, "start palette slot");
 	assertRange(0, end, 255, "pend alette slot");
 
-	uint8 *pal = _hePalettes + palSlot * 1024 + start * 3;
+	uint8 *pal = _hePalettes + palSlot * _hePaletteSlot + start * 3;
 
 	int bestsum = 0x7FFFFFFF;
 	int bestitem = start;
@@ -105,39 +126,83 @@ int ScummEngine_v90he::getHEPaletteSimilarColor(int palSlot, int red, int green,
 	return bestitem;
 }
 
+int ScummEngine_v90he::getHEPalette16BitColorComponent(int component, int type) {
+	uint16 col;
+	if (type == 2) {
+		col = (((component & 0xFFFF) >>  0) & 0x1F) << 3;;
+	} else if (type == 1) {
+		col = (((component & 0xFFFF) >>  5) & 0x1F) << 3;
+	} else {
+		col = (((component & 0xFFFF) >> 10) & 0x1F) << 3;
+	}
+	return col;
+}
+
 int ScummEngine_v90he::getHEPaletteColorComponent(int palSlot, int color, int component) {
 	assertRange(1, palSlot, _numPalettes, "palette");
 	assertRange(0, color, 255, "palette slot");
 
-	return _hePalettes[palSlot * 1024 + color * 3 + component % 3];
+	return _hePalettes[palSlot * _hePaletteSlot + color * 3 + component % 3];
 }
 
 int ScummEngine_v90he::getHEPaletteColor(int palSlot, int color) {
 	assertRange(1, palSlot, _numPalettes, "palette");
 	assertRange(0, color, 255, "palette slot");
 
-	return _hePalettes[palSlot * 1024 + 768 + color];
+	if (_game.features & GF_16BIT_COLOR)
+		return READ_LE_UINT16(_hePalettes + palSlot * _hePaletteSlot + 768 + color * 2);
+	else
+		return _hePalettes[palSlot * _hePaletteSlot + 768 + color];
 }
 
 void ScummEngine_v90he::setHEPaletteColor(int palSlot, uint8 color, uint8 r, uint8 g, uint8 b) {
 	debug(7, "setHEPaletteColor(%d, %d, %d, %d, %d)", palSlot, color, r, g, b);
 	assertRange(1, palSlot, _numPalettes, "palette");
-	uint8 *p = _hePalettes + palSlot * 1024 + color * 3;
+
+	uint8 *p = _hePalettes + palSlot * _hePaletteSlot + color * 3;
 	*(p + 0) = r;
 	*(p + 1) = g;
 	*(p + 2) = b;
-	_hePalettes[palSlot * 1024 + 768 + color] = color;
+	if (_game.features & GF_16BIT_COLOR) {
+		WRITE_LE_UINT16(_hePalettes + palSlot * _hePaletteSlot + 768 + color * 2, get16BitColor(r, g, b));
+	} else {
+		_hePalettes[palSlot * _hePaletteSlot + 768 + color] = color;
+	}
 }
 
 void ScummEngine_v90he::setHEPaletteFromPtr(int palSlot, const uint8 *palData) {
 	assertRange(1, palSlot, _numPalettes, "palette");
-	uint8 *pc = _hePalettes + palSlot * 1024;
+
+	uint8 *pc = _hePalettes + palSlot * _hePaletteSlot;
 	uint8 *pi = pc + 768;
-	for (int i = 0; i < 256; ++i) {
-		*pc++ = *palData++;
-		*pc++ = *palData++;
-		*pc++ = *palData++;
-		*pi++ = i;
+	if (_game.features & GF_16BIT_COLOR) {
+		for (int i = 0; i < 256; ++i) {
+			uint8 r = *pc++ = *palData++;
+			uint8 g = *pc++ = *palData++;
+			uint8 b = *pc++ = *palData++;
+			WRITE_LE_UINT16(pi, get16BitColor(r, g, b)); pi += 2;
+		}
+	} else {
+		for (int i = 0; i < 256; ++i) {
+			*pc++ = *palData++;
+			*pc++ = *palData++;
+			*pc++ = *palData++;
+			*pi++ = i;
+		}
+	}
+
+	int i;
+	uint8 *palPtr = _hePalettes + palSlot * _hePaletteSlot + 768;
+	if (_game.features & GF_16BIT_COLOR) {
+		for (i = 0; i < 10; ++i)
+			WRITE_LE_UINT16(palPtr + i * 2, i);
+		for (i = 246; i < 256; ++i)
+			WRITE_LE_UINT16(palPtr + i * 2, i);
+	} else {
+		for (i = 0; i < 10; ++i)
+			*(palPtr + i) = i;
+		for (i = 246; i < 256; ++i)
+			*(palPtr + i) = i;
 	}
 }
 
@@ -176,8 +241,9 @@ void ScummEngine_v90he::setHEPaletteFromRoom(int palSlot, int resId, int state)
 void ScummEngine_v90he::restoreHEPalette(int palSlot) {
 	debug(7, "restoreHEPalette(%d)", palSlot);
 	assertRange(1, palSlot, _numPalettes, "palette");
+
 	if (palSlot != 1) {
-		memcpy(_hePalettes + palSlot * 1024, _hePalettes + 1024, 1024);
+		memcpy(_hePalettes + palSlot * _hePaletteSlot, _hePalettes + _hePaletteSlot, _hePaletteSlot);
 	}
 }
 
@@ -185,18 +251,27 @@ void ScummEngine_v90he::copyHEPalette(int dstPalSlot, int srcPalSlot) {
 	debug(7, "copyHEPalette(%d, %d)", dstPalSlot, srcPalSlot);
 	assert(dstPalSlot >= 1 && dstPalSlot <= _numPalettes);
 	assert(srcPalSlot >= 1 && srcPalSlot <= _numPalettes);
+
 	if (dstPalSlot != srcPalSlot) {
-		memcpy(_hePalettes + dstPalSlot * 1024, _hePalettes + srcPalSlot * 1024, 1024);
+		memcpy(_hePalettes + dstPalSlot * _hePaletteSlot, _hePalettes + srcPalSlot * _hePaletteSlot, _hePaletteSlot);
 	}
 }
 
-void ScummEngine_v90he::copyHEPaletteColor(int palSlot, uint8 dstColor, uint8 srcColor) {
+void ScummEngine_v90he::copyHEPaletteColor(int palSlot, uint8 dstColor, uint16 srcColor) {
 	debug(7, "copyHEPaletteColor(%d, %d, %d)", palSlot, dstColor, srcColor);
 	assertRange(1, palSlot, _numPalettes, "palette");
-	uint8 *dstPal = _hePalettes + palSlot * 1024 + dstColor * 3;
-	uint8 *srcPal = _hePalettes + 1024 + srcColor * 3;
-	memcpy(dstPal, srcPal, 3);
-	_hePalettes[palSlot * 1024 + 768 + dstColor] = srcColor;
+
+	uint8 *dstPal = _hePalettes + palSlot * _hePaletteSlot + dstColor * 3;
+	uint8 *srcPal = _hePalettes + _hePaletteSlot + srcColor * 3;
+	if (_game.features & GF_16BIT_COLOR) {
+		dstPal[0] = (srcColor >> 10) << 3;
+		dstPal[1] = (srcColor >>  5) << 3;
+		dstPal[2] = (srcColor >>  0) << 3;
+		WRITE_LE_UINT16(_hePalettes + palSlot * _hePaletteSlot + 768 + dstColor * 2, srcColor);
+	} else {
+		memcpy(dstPal, srcPal, 3);
+		_hePalettes[palSlot * _hePaletteSlot + 768 + dstColor] = srcColor;
+	}
 }
 
 void ScummEngine_v99he::setPaletteFromPtr(const byte *ptr, int numcolor) {
@@ -209,7 +284,7 @@ void ScummEngine_v99he::setPaletteFromPtr(const byte *ptr, int numcolor) {
 
 	assertRange(0, numcolor, 256, "setPaletteFromPtr: numcolor");
 
-	dest = _hePalettes + 1024;
+	dest = _hePalettes + _hePaletteSlot;
 
 	for (i = 0; i < numcolor; i++) {
 		r = *ptr++;
@@ -220,48 +295,63 @@ void ScummEngine_v99he::setPaletteFromPtr(const byte *ptr, int numcolor) {
 			*dest++ = r;
 			*dest++ = g;
 			*dest++ = b;
-			_hePalettes[1792 + i] = i;
+
+			if (_game.features & GF_16BIT_COLOR) {
+				WRITE_LE_UINT16(_hePalettes + 2048 + i * 2, get16BitColor(r, g, b));
+			} else {
+				_hePalettes[1792 + i] = i;
+			}
 		} else {
 			dest += 3;
 		}
 	}
 
-	memcpy(_hePalettes, _hePalettes + 1024, 768);
-
-	for (i = 0; i < 10; ++i)
-		_hePalettes[1792 + i] = i;
-	for (i = 246; i < 256; ++i)
-		_hePalettes[1792 + i] = i;
+	memcpy(_hePalettes, _hePalettes + _hePaletteSlot, 768);
 
+	if (_game.features & GF_16BIT_COLOR) {
+		for (i = 0; i < 10; ++i)
+			WRITE_LE_UINT16(_hePalettes + 2048 + i * 2, i);
+		for (i = 246; i < 256; ++i)
+			WRITE_LE_UINT16(_hePalettes + 2048 + i * 2, i);
+	} else {
+		for (i = 0; i < 10; ++i)
+			_hePalettes[1792 + i] = i;
+		for (i = 246; i < 256; ++i)
+			_hePalettes[1792 + i] = i;
+	}
 	setDirtyColors(0, numcolor - 1);
 }
 
 void ScummEngine_v99he::darkenPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
 	uint8 *src, *dst;
-	int color, j;
+	int j, r, g, b;
 
 	src = _hePalettes + startColor * 3;
-	dst = _hePalettes + 1024 + startColor * 3;
+	dst = _hePalettes + _hePaletteSlot + startColor * 3;
 	for (j = startColor; j <= endColor; j++) {
-		color = *src++;
-		color = color * redScale / 0xFF;
-		if (color > 255)
-			color = 255;
-		*dst++ = color;
-
-		color = *src++;
-		color = color * greenScale / 0xFF;
-		if (color > 255)
-			color = 255;
-		*dst++ = color;
-
-		color = *src++;
-		color = color * blueScale / 0xFF;
-		if (color > 255)
-			color = 255;
-		*dst++ = color;
-
-		_hePalettes[1792 + j] = j;
+		r = *src++;
+		r = r * redScale / 0xFF;
+		if (r > 255)
+			r = 255;
+		*dst++ = r;
+
+		g = *src++;
+		g = g * greenScale / 0xFF;
+		if (g > 255)
+			g = 255;
+		*dst++ = g;
+
+		b = *src++;
+		b = b * blueScale / 0xFF;
+		if (b > 255)
+			b = 255;
+		*dst++ = b;
+
+		if (_game.features & GF_16BIT_COLOR) {
+			WRITE_LE_UINT16(_hePalettes + 2048 + j * 2, get16BitColor(r, g, b));
+		} else {
+			_hePalettes[1792 + j] = j;
+		}
 		setDirtyColors(j, endColor);
 	}
 }
@@ -272,26 +362,39 @@ void ScummEngine_v99he::copyPalColor(int dst, int src) {
 	if ((uint) dst >= 256 || (uint) src >= 256)
 		error("copyPalColor: invalid values, %d, %d", dst, src);
 
-	dp = &_hePalettes[1024 + dst * 3];
-	sp = &_hePalettes[1024 + src * 3];
+	dp = &_hePalettes[_hePaletteSlot + dst * 3];
+	sp = &_hePalettes[_hePaletteSlot + src * 3];
 
 	dp[0] = sp[0];
 	dp[1] = sp[1];
 	dp[2] = sp[2];
-	_hePalettes[1792 + dst] = dst;
+
+	if (_game.features & GF_16BIT_COLOR) {
+		WRITE_LE_UINT16(_hePalettes + 2048 + dst * 2, get16BitColor(sp[0], sp[1], sp[2]));
+	} else {
+		_hePalettes[1792 + dst] = dst;
+	}
 
 	setDirtyColors(dst, dst);
 }
 
 void ScummEngine_v99he::setPalColor(int idx, int r, int g, int b) {
-	_hePalettes[1024 + idx * 3 + 0] = r;
-	_hePalettes[1024 + idx * 3 + 1] = g;
-	_hePalettes[1024 + idx * 3 + 2] = b;
-	_hePalettes[1792 + idx] = idx;
+	_hePalettes[_hePaletteSlot + idx * 3 + 0] = r;
+	_hePalettes[_hePaletteSlot + idx * 3 + 1] = g;
+	_hePalettes[_hePaletteSlot + idx * 3 + 2] = b;
+
+	if (_game.features & GF_16BIT_COLOR) {
+		WRITE_LE_UINT16(_hePalettes + 2048 + idx * 2, get16BitColor(r, g, b));
+	} else {
+		_hePalettes[1792 + idx] = idx;
+	}
 	setDirtyColors(idx, idx);
 }
 
 void ScummEngine_v99he::updatePalette() {
+	if (_game.features & GF_16BIT_COLOR)
+		return;
+
 	if (_palDirtyMax == -1)
 		return;