Merge pull request #359 from rundfunk47/32bitguioverlay

GUI: Add option to render GUI in 32-bits

4 files changed, 95 insertions, 42 deletions

diff --git a/graphics/VectorRendererSpec.cpp b/graphics/VectorRendererSpec.cpp
index 4c5dd33cb5..1e01744fad 100644
--- a/graphics/VectorRendererSpec.cpp
+++ b/graphics/VectorRendererSpec.cpp
@@ -277,16 +277,22 @@ void colorFill(PixelType *first, PixelType *last, PixelType color) {
 
 VectorRenderer *createRenderer(int mode) {
 #ifdef DISABLE_FANCY_THEMES
-	assert(mode == GUI::ThemeEngine::kGfxStandard16bit);
+	assert(mode == GUI::ThemeEngine::kGfxStandard);
 #endif
 
 	PixelFormat format = g_system->getOverlayFormat();
 	switch (mode) {
-	case GUI::ThemeEngine::kGfxStandard16bit:
-		return new VectorRendererSpec<OverlayColor>(format);
+	case GUI::ThemeEngine::kGfxStandard:
+		if (g_system->getOverlayFormat().bytesPerPixel == 4)
+			return new VectorRendererSpec<uint32>(format);
+		else if (g_system->getOverlayFormat().bytesPerPixel == 2)
+			return new VectorRendererSpec<uint16>(format);
 #ifndef DISABLE_FANCY_THEMES
-	case GUI::ThemeEngine::kGfxAntialias16bit:
-		return new VectorRendererAA<OverlayColor>(format);
+	case GUI::ThemeEngine::kGfxAntialias:
+		if (g_system->getOverlayFormat().bytesPerPixel == 4)
+			return new VectorRendererAA<uint32>(format);
+		else if (g_system->getOverlayFormat().bytesPerPixel == 2)
+			return new VectorRendererAA<uint16>(format);
 #endif
 	default:
 		break;
@@ -317,9 +323,15 @@ setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2) {
 	_gradientEnd = _format.RGBToColor(r2, g2, b2);
 	_gradientStart = _format.RGBToColor(r1, g1, b1);
 
-	_gradientBytes[0] = (_gradientEnd & _redMask) - (_gradientStart & _redMask);
-	_gradientBytes[1] = (_gradientEnd & _greenMask) - (_gradientStart & _greenMask);
-	_gradientBytes[2] = (_gradientEnd & _blueMask) - (_gradientStart & _blueMask);
+	if (sizeof(PixelType) == 4) {
+		_gradientBytes[0] = ((_gradientEnd & _redMask) >> _format.rShift) - ((_gradientStart & _redMask) >> _format.rShift);
+		_gradientBytes[1] = ((_gradientEnd & _greenMask) >> _format.gShift) - ((_gradientStart & _greenMask) >> _format.gShift);
+		_gradientBytes[2] = ((_gradientEnd & _blueMask) >> _format.bShift) - ((_gradientStart & _blueMask) >> _format.bShift);
+	} else {
+		_gradientBytes[0] = (_gradientEnd & _redMask) - (_gradientStart & _redMask);
+		_gradientBytes[1] = (_gradientEnd & _greenMask) - (_gradientStart & _greenMask);
+		_gradientBytes[2] = (_gradientEnd & _blueMask) - (_gradientStart & _blueMask);
+	}
 }
 
 template<typename PixelType>
@@ -328,9 +340,15 @@ calcGradient(uint32 pos, uint32 max) {
 	PixelType output = 0;
 	pos = (MIN(pos * Base::_gradientFactor, max) << 12) / max;
 
-	output |= ((_gradientStart & _redMask) + ((_gradientBytes[0] * pos) >> 12)) & _redMask;
-	output |= ((_gradientStart & _greenMask) + ((_gradientBytes[1] * pos) >> 12)) & _greenMask;
-	output |= ((_gradientStart & _blueMask) + ((_gradientBytes[2] * pos) >> 12)) & _blueMask;
+	if (sizeof(PixelType) == 4) {
+		output |= ((_gradientStart & _redMask) + (((_gradientBytes[0] * pos) >> 12) << _format.rShift)) & _redMask;
+		output |= ((_gradientStart & _greenMask) + (((_gradientBytes[1] * pos) >> 12) << _format.gShift)) & _greenMask;
+		output |= ((_gradientStart & _blueMask) + (((_gradientBytes[2] * pos) >> 12) << _format.bShift)) & _blueMask;
+	} else {
+		output |= ((_gradientStart & _redMask) + ((_gradientBytes[0] * pos) >> 12)) & _redMask;
+		output |= ((_gradientStart & _greenMask) + ((_gradientBytes[1] * pos) >> 12)) & _greenMask;
+		output |= ((_gradientStart & _blueMask) + ((_gradientBytes[2] * pos) >> 12)) & _blueMask;
+	}
 	output |= _alphaMask;
 
 	return output;
@@ -537,20 +555,41 @@ applyScreenShading(GUI::ThemeEngine::ShadingStyle shadingStyle) {
 template<typename PixelType>
 inline void VectorRendererSpec<PixelType>::
 blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha) {
-	int idst = *ptr;
-	int isrc = color;
-
-	*ptr = (PixelType)(
-		(_redMask & ((idst & _redMask) +
-		((int)(((int)(isrc & _redMask) -
-		(int)(idst & _redMask)) * alpha) >> 8))) |
-		(_greenMask & ((idst & _greenMask) +
-		((int)(((int)(isrc & _greenMask) -
-		(int)(idst & _greenMask)) * alpha) >> 8))) |
-		(_blueMask & ((idst & _blueMask) +
-		((int)(((int)(isrc & _blueMask) -
-		(int)(idst & _blueMask)) * alpha) >> 8))) |
-		(idst & _alphaMask));
+	if (sizeof(PixelType) == 4) {
+		const byte sR = (color & _redMask) >> _format.rShift;
+		const byte sG = (color & _greenMask) >> _format.gShift;
+		const byte sB = (color & _blueMask) >> _format.bShift;
+
+		byte dR = (*ptr & _redMask) >> _format.rShift;
+		byte dG = (*ptr & _greenMask) >> _format.gShift;
+		byte dB = (*ptr & _blueMask) >> _format.bShift;
+
+		dR += ((sR - dR) * alpha) >> 8;
+		dG += ((sG - dG) * alpha) >> 8;
+		dB += ((sB - dB) * alpha) >> 8;
+
+		*ptr = ((dR << _format.rShift) & _redMask)
+		     | ((dG << _format.gShift) & _greenMask)
+		     | ((dB << _format.bShift) & _blueMask)
+		     | (*ptr & _alphaMask);
+	} else if (sizeof(PixelType) == 2) {
+		int idst = *ptr;
+		int isrc = color;
+
+		*ptr = (PixelType)(
+			(_redMask & ((idst & _redMask) +
+			((int)(((int)(isrc & _redMask) -
+			(int)(idst & _redMask)) * alpha) >> 8))) |
+			(_greenMask & ((idst & _greenMask) +
+			((int)(((int)(isrc & _greenMask) -
+			(int)(idst & _greenMask)) * alpha) >> 8))) |
+			(_blueMask & ((idst & _blueMask) +
+			((int)(((int)(isrc & _blueMask) -
+			(int)(idst & _blueMask)) * alpha) >> 8))) |
+			(idst & _alphaMask));
+	} else {
+		error("Unsupported BPP format: %d", sizeof(PixelType));
+	}
 }
 
 template<typename PixelType>
diff --git a/graphics/fonts/bdf.cpp b/graphics/fonts/bdf.cpp
index 6d4befa37c..e523a36ad5 100644
--- a/graphics/fonts/bdf.cpp
+++ b/graphics/fonts/bdf.cpp
@@ -102,7 +102,7 @@ void BdfFont::drawChar(Surface *dst, byte chr, const int tx, const int ty, const
 	// equal to 50 and the decision of the theme designer?
 	// asserting _data.maxAdvance <= 50: let the theme designer decide what looks best
 	assert(_data.maxAdvance <= 50);
-	assert(dst->format.bytesPerPixel == 1 || dst->format.bytesPerPixel == 2);
+	assert(dst->format.bytesPerPixel == 1 || dst->format.bytesPerPixel == 2 || dst->format.bytesPerPixel == 4);
 
 	const int idx = mapToIndex(chr);
 	if (idx < 0)
@@ -165,6 +165,8 @@ void BdfFont::drawChar(Surface *dst, byte chr, const int tx, const int ty, const
 		drawCharIntern<byte>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color);
 	else if (dst->format.bytesPerPixel == 2)
 		drawCharIntern<uint16>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color);
+	else if (dst->format.bytesPerPixel == 4)
+		drawCharIntern<uint32>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color);
 }
 
 namespace {
diff --git a/gui/ThemeEngine.cpp b/gui/ThemeEngine.cpp
index 0f8b449b58..561c0244a2 100644
--- a/gui/ThemeEngine.cpp
+++ b/gui/ThemeEngine.cpp
@@ -343,9 +343,9 @@ ThemeEngine::~ThemeEngine() {
  *********************************************************/
 const ThemeEngine::Renderer ThemeEngine::_rendererModes[] = {
 	{ _s("Disabled GFX"), _sc("Disabled GFX", "lowres"), "none", kGfxDisabled },
-	{ _s("Standard Renderer (16bpp)"), _s("Standard (16bpp)"), "normal_16bpp", kGfxStandard16bit },
+	{ _s("Standard Renderer"), _s("Standard"), "normal", kGfxStandard },
 #ifndef DISABLE_FANCY_THEMES
-	{ _s("Antialiased Renderer (16bpp)"), _s("Antialiased (16bpp)"), "aa_16bpp", kGfxAntialias16bit }
+	{ _s("Antialiased Renderer"), _s("Antialiased"), "antialias", kGfxAntialias }
 #endif
 };
 
@@ -353,9 +353,9 @@ const uint ThemeEngine::_rendererModesSize = ARRAYSIZE(ThemeEngine::_rendererMod
 
 const ThemeEngine::GraphicsMode ThemeEngine::_defaultRendererMode =
 #ifndef DISABLE_FANCY_THEMES
-	ThemeEngine::kGfxAntialias16bit;
+	ThemeEngine::kGfxAntialias;
 #else
-	ThemeEngine::kGfxStandard16bit;
+	ThemeEngine::kGfxStandard;
 #endif
 
 ThemeEngine::GraphicsMode ThemeEngine::findMode(const Common::String &cfg) {
@@ -494,13 +494,17 @@ void ThemeEngine::disable() {
 
 void ThemeEngine::setGraphicsMode(GraphicsMode mode) {
 	switch (mode) {
-	case kGfxStandard16bit:
+	case kGfxStandard:
 #ifndef DISABLE_FANCY_THEMES
-	case kGfxAntialias16bit:
+	case kGfxAntialias:
 #endif
-		_bytesPerPixel = sizeof(uint16);
-		break;
-
+		if (g_system->getOverlayFormat().bytesPerPixel == 4) {
+			_bytesPerPixel = sizeof(uint32);
+			break;
+		} else if (g_system->getOverlayFormat().bytesPerPixel == 2) {
+			_bytesPerPixel = sizeof(uint16);
+			break;
+		}
 	default:
 		error("Invalid graphics mode");
 	}
@@ -1320,22 +1324,31 @@ bool ThemeEngine::createCursor(const Common::String &filename, int hotspotX, int
 	memset(_cursor, 0xFF, sizeof(byte) * _cursorWidth * _cursorHeight);
 
 	// the transparent color is 0xFF00FF
-	const int colTransparent = _overlayFormat.RGBToColor(0xFF, 0, 0xFF);
+	const uint32 colTransparent = _overlayFormat.RGBToColor(0xFF, 0, 0xFF);
 
 	// Now, scan the bitmap. We have to convert it from 16 bit color mode
 	// to 8 bit mode, and have to create a suitable palette on the fly.
 	uint colorsFound = 0;
 	Common::HashMap<int, int> colorToIndex;
-	const OverlayColor *src = (const OverlayColor *)cursor->getPixels();
+	const byte *src = (const byte *)cursor->getPixels();
 	for (uint y = 0; y < _cursorHeight; ++y) {
 		for (uint x = 0; x < _cursorWidth; ++x) {
+			uint32 color = colTransparent;
 			byte r, g, b;
 
+			if (cursor->format.bytesPerPixel == 2) {
+				color = READ_UINT16(src);
+			} else if (cursor->format.bytesPerPixel == 4) {
+				color = READ_UINT32(src);
+			}
+
+			src += cursor->format.bytesPerPixel;
+
 			// Skip transparency
-			if (src[x] == colTransparent)
+			if (color == colTransparent)
 				continue;
 
-			_overlayFormat.colorToRGB(src[x], r, g, b);
+			cursor->format.colorToRGB(color, r, g, b);
 			const int col = (r << 16) | (g << 8) | b;
 
 			// If there is no entry yet for this color in the palette: Add one
@@ -1357,7 +1370,6 @@ bool ThemeEngine::createCursor(const Common::String &filename, int hotspotX, int
 			const int index = colorToIndex[col];
 			_cursor[y * _cursorWidth + x] = index;
 		}
-		src += _cursorWidth;
 	}
 
 	_useCursor = true;
diff --git a/gui/ThemeEngine.h b/gui/ThemeEngine.h
index 160ceb3259..c0e47a19e6 100644
--- a/gui/ThemeEngine.h
+++ b/gui/ThemeEngine.h
@@ -250,8 +250,8 @@ public:
 	 */
 	enum GraphicsMode {
 		kGfxDisabled = 0,   ///< No GFX
-		kGfxStandard16bit,  ///< 2BPP with the standard (aliased) renderer.
-		kGfxAntialias16bit  ///< 2BPP with the optimized AA renderer.
+		kGfxStandard,  ///< Standard (aliased) renderer.
+		kGfxAntialias  ///< Optimized AA renderer.
 	};
 
 	/** Constant value to expand dirty rectangles, to make sure they are fully copied */