1 files changed, 91 insertions, 229 deletions

diff --git a/engines/sci/graphics/screen.cpp b/engines/sci/graphics/screen.cpp
index 2f95bf7751..601ab9f09f 100644
--- a/engines/sci/graphics/screen.cpp
+++ b/engines/sci/graphics/screen.cpp
@@ -50,13 +50,9 @@ GfxScreen::GfxScreen(ResourceManager *resMan) : _resMan(resMan) {
 	// to provide that under DOS as well, but as gk1/floppy does support
 	// upscaled hires scriptswise, but doesn't actually have the hires content
 	// we need to limit it to platform windows.
-	if (g_sci->getPlatform() == Common::kPlatformWindows) {
+	if ((g_sci->getPlatform() == Common::kPlatformWindows) || (g_sci->forceHiresGraphics())) {
 		if (g_sci->getGameId() == GID_KQ6)
 			_upscaledHires = GFX_SCREEN_UPSCALED_640x440;
-#ifdef ENABLE_SCI32
-		if (g_sci->getGameId() == GID_GK1)
-			_upscaledHires = GFX_SCREEN_UPSCALED_640x480;
-#endif
 	}
 
 	// Japanese versions of games use hi-res font on upscaled version of the game.
@@ -81,34 +77,18 @@ GfxScreen::GfxScreen(ResourceManager *resMan) : _resMan(resMan) {
 		case GID_LSL1:
 		case GID_LSL5:
 		case GID_SQ1:
-			_width = 190;
+			_scriptHeight = 190;
+			break;
 		default:
 			break;
 		}
 	}
 
-#ifdef ENABLE_SCI32
-	// GK1 Mac uses a 640x480 resolution too
-	if (g_sci->getPlatform() == Common::kPlatformMacintosh) {
-		if (g_sci->getGameId() == GID_GK1)
-			_upscaledHires = GFX_SCREEN_UPSCALED_640x480;
-	}
-#endif
-
 	if (_resMan->detectHires()) {
 		_scriptWidth = 640;
 		_scriptHeight = 480;
 	}
 
-#ifdef ENABLE_SCI32
-	// Phantasmagoria 1 effectively outputs 630x450
-	//  Coordinate translation has to use this resolution as well
-	if (g_sci->getGameId() == GID_PHANTASMAGORIA) {
-		_width = 630;
-		_height = 450;
-	}
-#endif
-
 	// if not yet set, set those to script-width/height
 	if (!_width)
 		_width = _scriptWidth;
@@ -211,36 +191,6 @@ GfxScreen::GfxScreen(ResourceManager *resMan) : _resMan(resMan) {
 			error("Unknown SCI1.1 Mac game");
 	} else
 		initGraphics(_displayWidth, _displayHeight, _displayWidth > 320);
-
-	// Initialize code pointers
-	_vectorAdjustCoordinatePtr = &GfxScreen::vectorAdjustCoordinateNOP;
-	_vectorAdjustLineCoordinatesPtr = &GfxScreen::vectorAdjustLineCoordinatesNOP;
-	_vectorIsFillMatchPtr = &GfxScreen::vectorIsFillMatchNormal;
-	_vectorPutPixelPtr = &GfxScreen::putPixelNormal;
-	_vectorPutLinePixelPtr = &GfxScreen::putPixel;
-	_vectorGetPixelPtr = &GfxScreen::getPixelNormal;
-	_putPixelPtr = &GfxScreen::putPixelNormal;
-	_getPixelPtr = &GfxScreen::getPixelNormal;
-	
-	switch (_upscaledHires) {
-	case GFX_SCREEN_UPSCALED_480x300:
-		_vectorAdjustCoordinatePtr = &GfxScreen::vectorAdjustCoordinate480x300Mac;
-		_vectorAdjustLineCoordinatesPtr = &GfxScreen::vectorAdjustLineCoordinates480x300Mac;
-		// vectorPutPixel -> we already adjust coordinates for vector code, that's why we can set pixels directly
-		// vectorGetPixel -> see vectorPutPixel
-		_vectorPutLinePixelPtr = &GfxScreen::vectorPutLinePixel480x300Mac;
-		_putPixelPtr = &GfxScreen::putPixelAllUpscaled;
-		_getPixelPtr = &GfxScreen::getPixelUpscaled;
-		break;
-	case GFX_SCREEN_UPSCALED_640x400:
-	case GFX_SCREEN_UPSCALED_640x440:
-	case GFX_SCREEN_UPSCALED_640x480:
-		_vectorPutPixelPtr = &GfxScreen::putPixelDisplayUpscaled;
-		_putPixelPtr = &GfxScreen::putPixelDisplayUpscaled;
-		break;
-	case GFX_SCREEN_UPSCALED_DISABLED:
-		break;
-	}
 }
 
 GfxScreen::~GfxScreen() {
@@ -250,22 +200,43 @@ GfxScreen::~GfxScreen() {
 	free(_displayScreen);
 }
 
+// should not be used regularly; only meant for restore game
+void GfxScreen::clearForRestoreGame() {
+	// reset all screen data
+	memset(_visualScreen, 0, _pixels);
+	memset(_priorityScreen, 0, _pixels);
+	memset(_controlScreen, 0, _pixels);
+	memset(_displayScreen, 0, _displayPixels);
+	memset(&_ditheredPicColors, 0, sizeof(_ditheredPicColors));
+	_fontIsUpscaled = false;
+	copyToScreen();
+}
+
 void GfxScreen::copyToScreen() {
 	g_system->copyRectToScreen(_activeScreen, _displayWidth, 0, 0, _displayWidth, _displayHeight);
 }
 
 void GfxScreen::copyFromScreen(byte *buffer) {
-	// TODO this ignores the pitch
 	Graphics::Surface *screen = g_system->lockScreen();
-	memcpy(buffer, screen->getPixels(), _displayPixels);
+
+	if (screen->pitch == _displayWidth) {
+		memcpy(buffer, screen->getPixels(), _displayPixels);
+	} else {
+		const byte *src = (const byte *)screen->getPixels();
+		uint height = _displayHeight;
+
+		while (height--) {
+			memcpy(buffer, src, _displayWidth);
+			buffer += _displayWidth;
+			src    += screen->pitch;
+		}
+	}
+
 	g_system->unlockScreen();
 }
 
 void GfxScreen::kernelSyncWithFramebuffer() {
-	// TODO this ignores the pitch
-	Graphics::Surface *screen = g_system->lockScreen();
-	memcpy(_displayScreen, screen->getPixels(), _displayPixels);
-	g_system->unlockScreen();
+	copyFromScreen(_displayScreen);
 }
 
 void GfxScreen::copyRectToScreen(const Common::Rect &rect) {
@@ -310,40 +281,68 @@ byte GfxScreen::getDrawingMask(byte color, byte prio, byte control) {
 	return flag;
 }
 
-void GfxScreen::vectorAdjustCoordinateNOP(int16 *x, int16 *y) {
+void GfxScreen::vectorAdjustLineCoordinates(int16 *left, int16 *top, int16 *right, int16 *bottom, byte drawMask, byte color, byte priority, byte control) {
+	switch (_upscaledHires) {
+	case GFX_SCREEN_UPSCALED_480x300: {
+		int16 displayLeft = (*left * 3) / 2;
+		int16 displayRight = (*right * 3) / 2;
+		int16 displayTop = (*top * 3) / 2;
+		int16 displayBottom = (*bottom * 3) / 2;
+
+		if (displayLeft < displayRight) {
+			// one more pixel to the left, one more pixel to the right
+			if (displayLeft > 0)
+				vectorPutLinePixel(displayLeft - 1, displayTop, drawMask, color, priority, control);
+			vectorPutLinePixel(displayRight + 1, displayBottom, drawMask, color, priority, control);
+		} else if (displayLeft > displayRight) {
+			if (displayRight > 0)
+				vectorPutLinePixel(displayRight - 1, displayBottom, drawMask, color, priority, control);
+			vectorPutLinePixel(displayLeft + 1, displayTop, drawMask, color, priority, control);
+		}
+		*left = displayLeft;
+		*top = displayTop;
+		*right = displayRight;
+		*bottom = displayBottom;
+		break;
+	}
+	default:
+		break;
+	}
 }
 
-void GfxScreen::vectorAdjustCoordinate480x300Mac(int16 *x, int16 *y) {
-	*x = _upscaledWidthMapping[*x];
-	*y = _upscaledHeightMapping[*y];
+// This is called from vector drawing to put a pixel at a certain location
+void GfxScreen::vectorPutLinePixel(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
+	if (_upscaledHires == GFX_SCREEN_UPSCALED_480x300) {
+		vectorPutLinePixel480x300(x, y, drawMask, color, priority, control);
+		return;		
+	}
+
+	// For anything else forward to the regular putPixel
+	putPixel(x, y, drawMask, color, priority, control);
 }
 
-void GfxScreen::vectorAdjustLineCoordinatesNOP(int16 *left, int16 *top, int16 *right, int16 *bottom, byte drawMask, byte color, byte priority, byte control) {
+// Special 480x300 Mac putPixel for vector line drawing, also draws an additional pixel below the actual one
+void GfxScreen::vectorPutLinePixel480x300(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
+	int offset = y * _width + x;
+
+	if (drawMask & GFX_SCREEN_MASK_VISUAL) {
+		// also set pixel below actual pixel
+		_visualScreen[offset] = color;
+		_visualScreen[offset + _width] = color;
+		_displayScreen[offset] = color;
+		_displayScreen[offset + _displayWidth] = color;
+	}
+	if (drawMask & GFX_SCREEN_MASK_PRIORITY) {
+		_priorityScreen[offset] = priority;
+		_priorityScreen[offset + _width] = priority;
+	}
+	if (drawMask & GFX_SCREEN_MASK_CONTROL) {
+		_controlScreen[offset] = control;
+		_controlScreen[offset + _width] = control;
+	}
 }
 
-void GfxScreen::vectorAdjustLineCoordinates480x300Mac(int16 *left, int16 *top, int16 *right, int16 *bottom, byte drawMask, byte color, byte priority, byte control) {
-	int16 displayLeft = _upscaledWidthMapping[*left];
-	int16 displayRight = _upscaledWidthMapping[*right];
-	int16 displayTop = _upscaledHeightMapping[*top];
-	int16 displayBottom = _upscaledHeightMapping[*bottom];
-	
-	if (displayLeft < displayRight) {
-		// one more pixel to the left, one more pixel to the right
-		if (displayLeft > 0)
-			vectorPutLinePixel(displayLeft - 1, displayTop, drawMask, color, priority, control);
-		vectorPutLinePixel(displayRight + 1, displayBottom, drawMask, color, priority, control);
-	} else if (displayLeft > displayRight) {
-		if (displayRight > 0)
-			vectorPutLinePixel(displayRight - 1, displayBottom, drawMask, color, priority, control);
-		vectorPutLinePixel(displayLeft + 1, displayTop, drawMask, color, priority, control);
-	}
-	*left = displayLeft;
-	*top = displayTop;
-	*right = displayRight;
-	*bottom = displayBottom;
-}
-
-byte GfxScreen::vectorIsFillMatchNormal(int16 x, int16 y, byte screenMask, byte checkForColor, byte checkForPriority, byte checkForControl, bool isEGA) {
+byte GfxScreen::vectorIsFillMatch(int16 x, int16 y, byte screenMask, byte checkForColor, byte checkForPriority, byte checkForControl, bool isEGA) {
 	int offset = y * _width + x;
 	byte match = 0;
 
@@ -373,132 +372,6 @@ byte GfxScreen::vectorIsFillMatchNormal(int16 x, int16 y, byte screenMask, byte
 	return match;
 }
 
-// Special 480x300 Mac putPixel for vector line drawing, also draws an additional pixel below the actual one
-void GfxScreen::vectorPutLinePixel480x300Mac(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
-	int offset = y * _width + x;
-	
-	if (drawMask & GFX_SCREEN_MASK_VISUAL) {
-		_visualScreen[offset] = color;
-		_visualScreen[offset + _width] = color;
-		_displayScreen[offset] = color;
-		// also set pixel below actual pixel
-		_displayScreen[offset + _displayWidth] = color;
-	}
-	if (drawMask & GFX_SCREEN_MASK_PRIORITY) {
-		_priorityScreen[offset] = priority;
-		_priorityScreen[offset + _width] = priority;
-	}
-	if (drawMask & GFX_SCREEN_MASK_CONTROL) {
-		_controlScreen[offset] = control;
-		_controlScreen[offset + _width] = control;
-	}
-}
-
-// Directly sets a pixel on various screens, display is not upscaled
-void GfxScreen::putPixelNormal(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
-	int offset = y * _width + x;
-
-	if (drawMask & GFX_SCREEN_MASK_VISUAL) {
-		_visualScreen[offset] = color;
-		_displayScreen[offset] = color;
-	}
-	if (drawMask & GFX_SCREEN_MASK_PRIORITY)
-		_priorityScreen[offset] = priority;
-	if (drawMask & GFX_SCREEN_MASK_CONTROL)
-		_controlScreen[offset] = control;
-}
-
-// Directly sets a pixel on various screens, display IS upscaled
-void GfxScreen::putPixelDisplayUpscaled(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
-	int offset = y * _width + x;
-
-	if (drawMask & GFX_SCREEN_MASK_VISUAL) {
-		_visualScreen[offset] = color;
-		putScaledPixelOnScreen(_displayScreen, x, y, color);
-	}
-	if (drawMask & GFX_SCREEN_MASK_PRIORITY)
-		_priorityScreen[offset] = priority;
-	if (drawMask & GFX_SCREEN_MASK_CONTROL)
-		_controlScreen[offset] = control;
-}
-
-// Directly sets a pixel on various screens, ALL screens ARE upscaled
-void GfxScreen::putPixelAllUpscaled(int16 x, int16 y, byte drawMask, byte color, byte priority, byte control) {
-	if (drawMask & GFX_SCREEN_MASK_VISUAL) {
-		putScaledPixelOnScreen(_visualScreen, x, y, color);
-		putScaledPixelOnScreen(_displayScreen, x, y, color);
-	}
-	if (drawMask & GFX_SCREEN_MASK_PRIORITY)
-		putScaledPixelOnScreen(_priorityScreen, x, y, priority);
-	if (drawMask & GFX_SCREEN_MASK_CONTROL)
-		putScaledPixelOnScreen(_controlScreen, x, y, control);
-}
-
-/**
- * This is used to put font pixels onto the screen - we adjust differently, so that we won't
- *  do triple pixel lines in any case on upscaled hires. That way the font will not get distorted
- *  Sierra SCI didn't do this
- */
-void GfxScreen::putFontPixel(int16 startingY, int16 x, int16 y, byte color) {
-	int16 actualY = startingY + y;
-	if (_fontIsUpscaled) {
-		// Do not scale ourselves, but put it on the display directly
-		putPixelOnDisplay(x, actualY, color);
-	} else {
-		int offset = actualY * _width + x;
-
-		_visualScreen[offset] = color;
-		switch (_upscaledHires) {
-		case GFX_SCREEN_UPSCALED_DISABLED:
-			_displayScreen[offset] = color;
-			break;
-		case GFX_SCREEN_UPSCALED_640x400:
-		case GFX_SCREEN_UPSCALED_640x440:
-		case GFX_SCREEN_UPSCALED_640x480: {
-			// to 1-> 4 pixels upscaling for all of those, so that fonts won't look weird
-			int displayOffset = (_upscaledHeightMapping[startingY] + y * 2) * _displayWidth + x * 2;
-			_displayScreen[displayOffset] = color;
-			_displayScreen[displayOffset + 1] = color;
-			displayOffset += _displayWidth;
-			_displayScreen[displayOffset] = color;
-			_displayScreen[displayOffset + 1] = color;
-			break;
-		}
-		default:
-			putScaledPixelOnScreen(_displayScreen, x, actualY, color);
-			break;
-		}
-	}
-}
-
-/**
- * This will just change a pixel directly on displayscreen. It is supposed to be
- * only used on upscaled-Hires games where hires content needs to get drawn ONTO
- * the upscaled display screen (like japanese fonts, hires portraits, etc.).
- */
-void GfxScreen::putPixelOnDisplay(int16 x, int16 y, byte color) {
-	int offset = y * _displayWidth + x;
-	_displayScreen[offset] = color;
-}
-
-//void GfxScreen::putScaledPixelOnDisplay(int16 x, int16 y, byte color) {
-//}
-
-void GfxScreen::putScaledPixelOnScreen(byte *screen, int16 x, int16 y, byte data) {
-	int displayOffset = _upscaledHeightMapping[y] * _displayWidth + _upscaledWidthMapping[x];
-	int heightOffsetBreak = (_upscaledHeightMapping[y + 1] - _upscaledHeightMapping[y]) * _displayWidth;
-	int heightOffset = 0;
-	int widthOffsetBreak = _upscaledWidthMapping[x + 1] - _upscaledWidthMapping[x];
-	do {
-		int widthOffset = 0;
-		do {
-			screen[displayOffset + heightOffset + widthOffset] = data;
-			widthOffset++;
-		} while (widthOffset != widthOffsetBreak);
-		heightOffset += _displayWidth;
-	} while (heightOffset != heightOffsetBreak);
-}
-
 /**
  * Sierra's Bresenham line drawing.
  * WARNING: Do not replace this with Graphics::drawLine(), as this causes issues
@@ -580,16 +453,6 @@ void GfxScreen::putKanjiChar(Graphics::FontSJIS *commonFont, int16 x, int16 y, u
 	commonFont->drawChar(displayPtr, chr, _displayWidth, 1, color, 0, -1, -1);
 }
 
-byte GfxScreen::getPixelNormal(byte *screen, int16 x, int16 y) {
-	return screen[y * _width + x];
-}
-
-byte GfxScreen::getPixelUpscaled(byte *screen, int16 x, int16 y) {
-	int16 mappedX = _upscaledWidthMapping[x];
-	int16 mappedY = _upscaledHeightMapping[y];
-	return screen[mappedY * _width + mappedX];
-}
-
 int GfxScreen::bitsGetDataSize(Common::Rect rect, byte mask) {
 	int byteCount = sizeof(rect) + sizeof(mask);
 	int pixels = rect.width() * rect.height();
@@ -600,7 +463,7 @@ int GfxScreen::bitsGetDataSize(Common::Rect rect, byte mask) {
 		} else {
 			int rectHeight = _upscaledHeightMapping[rect.bottom] - _upscaledHeightMapping[rect.top];
 			int rectWidth = _upscaledWidthMapping[rect.right] - _upscaledWidthMapping[rect.left];
-			byteCount += rectHeight * rect.width() * rectWidth; // _displayScreen (upscaled hires)
+			byteCount += rectHeight * rectWidth; // _displayScreen (upscaled hires)
 		}
 	}
 	if (mask & GFX_SCREEN_MASK_PRIORITY) {
@@ -614,7 +477,6 @@ int GfxScreen::bitsGetDataSize(Common::Rect rect, byte mask) {
 			error("bitsGetDataSize() called w/o being in upscaled hires mode");
 		byteCount += pixels; // _displayScreen (coordinates actually are given to us for hires displayScreen)
 	}
-
 	return byteCount;
 }
 
@@ -747,13 +609,13 @@ void GfxScreen::setVerticalShakePos(uint16 shakePos) {
 
 void GfxScreen::kernelShakeScreen(uint16 shakeCount, uint16 directions) {
 	while (shakeCount--) {
-		if (directions & SCI_SHAKE_DIRECTION_VERTICAL)
+		if (directions & kShakeVertical)
 			setVerticalShakePos(10);
 		// TODO: horizontal shakes
 		g_system->updateScreen();
 		g_sci->getEngineState()->wait(3);
 
-		if (directions & SCI_SHAKE_DIRECTION_VERTICAL)
+		if (directions & kShakeVertical)
 			setVerticalShakePos(0);
 
 		g_system->updateScreen();
@@ -781,7 +643,7 @@ void GfxScreen::dither(bool addToFlag) {
 						*displayPtr = color;
 						break;
 					default:
-						putScaledPixelOnScreen(_displayScreen, x, y, color);
+						putScaledPixelOnDisplay(x, y, color);
 						break;
 					}
 					*visualPtr = color;
@@ -813,7 +675,7 @@ void GfxScreen::dither(bool addToFlag) {
 						*displayPtr = ditheredColor;
 						break;
 					default:
-						putScaledPixelOnScreen(_displayScreen, x, y, ditheredColor);
+						putScaledPixelOnDisplay(x, y, ditheredColor);
 						break;
 					}
 					color = ((x^y) & 1) ? color >> 4 : color & 0x0F;