Renamed /gui to /graphics and /sfx to /sound, to better illustrate their purpose

svn-id: r47007

1 files changed, 513 insertions, 0 deletions

diff --git a/engines/sci/graphics/gui_screen.cpp b/engines/sci/graphics/gui_screen.cpp
new file mode 100644
index 0000000000..13f969e55f
--- /dev/null
+++ b/engines/sci/graphics/gui_screen.cpp
@@ -0,0 +1,513 @@
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/timer.h"
+#include "common/util.h"
+#include "graphics/surface.h"
+
+#include "sci/sci.h"
+#include "sci/engine/state.h"
+#include "sci/graphics/gui_screen.h"
+
+namespace Sci {
+
+SciGuiScreen::SciGuiScreen(ResourceManager *resMan, int16 width, int16 height, bool upscaledHires) : 
+	_resMan(resMan), _width(width), _height(height), _upscaledHires(upscaledHires) {
+
+	_pixels = _width * _height;
+
+	_displayWidth = _width;
+	_displayHeight = _height;
+	if (_upscaledHires) {
+		_displayWidth *= 2;
+		_displayHeight *= 2;
+	}
+	_displayPixels = _displayWidth * _displayHeight;
+
+	_visualScreen = (byte *)calloc(_pixels, 1);
+	_priorityScreen = (byte *)calloc(_pixels, 1);
+	_controlScreen = (byte *)calloc(_pixels, 1);
+	_displayScreen = (byte *)calloc(_displayPixels, 1);
+
+	// Sets display screen to be actually displayed
+	_activeScreen = _displayScreen;
+
+	_picNotValid = 0;
+	_picNotValidSci11 = 0;
+	_unditherState = true;
+
+	if (_resMan->isVGA()) {
+		_colorWhite = 255;
+		if (getSciVersion() >= SCI_VERSION_1_1)
+			_colorDefaultVectorData = 255;
+		else
+			_colorDefaultVectorData = 0;
+	} else {
+		_colorWhite = 15;
+		_colorDefaultVectorData = 0;
+	}
+
+	// Initialize the actual screen
+	initGraphics(_displayWidth, _displayHeight, _displayWidth > 320);
+}
+
+SciGuiScreen::~SciGuiScreen() {
+	free(_visualScreen);
+	free(_priorityScreen);
+	free(_controlScreen);
+	free(_displayScreen);
+}
+
+void SciGuiScreen::copyToScreen() {
+	g_system->copyRectToScreen(_activeScreen, _displayWidth, 0, 0, _displayWidth, _displayHeight);
+}
+
+void SciGuiScreen::copyFromScreen(byte *buffer) {
+	Graphics::Surface *screen;
+	screen = g_system->lockScreen();
+	memcpy(buffer, screen->pixels, _displayWidth * _displayHeight);
+	g_system->unlockScreen();
+}
+
+void SciGuiScreen::copyRectToScreen(const Common::Rect &rect) {
+	if (!_upscaledHires)  {
+		g_system->copyRectToScreen(_activeScreen + rect.top * _displayWidth + rect.left, _displayWidth, rect.left, rect.top, rect.width(), rect.height());
+	} else {
+		g_system->copyRectToScreen(_activeScreen + rect.top * 2 * _displayWidth + rect.left * 2, _displayWidth, rect.left * 2, rect.top * 2, rect.width() * 2, rect.height() * 2);
+	}
+}
+
+void SciGuiScreen::copyRectToScreen(const Common::Rect &rect, int16 x, int16 y) {
+	if (!_upscaledHires)  {
+		g_system->copyRectToScreen(_activeScreen + rect.top * _displayWidth + rect.left, _displayWidth, x, y, rect.width(), rect.height());
+	} else {
+		g_system->copyRectToScreen(_activeScreen + rect.top * 2 * _displayWidth + rect.left * 2, _displayWidth, x * 2, y * 2, rect.width() * 2, rect.height() * 2);
+	}
+}
+
+byte SciGuiScreen::getDrawingMask(byte color, byte prio, byte control) {
+	byte flag = 0;
+	if (color != 255)
+		flag |= SCI_SCREEN_MASK_VISUAL;
+	if (prio != 255)
+		flag |= SCI_SCREEN_MASK_PRIORITY;
+	if (control != 255)
+		flag |= SCI_SCREEN_MASK_CONTROL;
+	return flag;
+}
+
+void SciGuiScreen::putPixel(int x, int y, byte drawMask, byte color, byte priority, byte control) {
+	int offset = y * _width + x;
+
+	if (drawMask & SCI_SCREEN_MASK_VISUAL) {
+		_visualScreen[offset] = color;
+		if (!_upscaledHires) {
+			_displayScreen[offset] = color;
+		} else {
+			int displayOffset = y * 2 * _displayWidth + x * 2;
+			_displayScreen[displayOffset] = color;
+			_displayScreen[displayOffset + 1] = color;
+			_displayScreen[displayOffset + _displayWidth] = color;
+			_displayScreen[displayOffset + _displayWidth + 1] = color;
+		}
+	}
+	if (drawMask & SCI_SCREEN_MASK_PRIORITY)
+		_priorityScreen[offset] = priority;
+	if (drawMask & SCI_SCREEN_MASK_CONTROL)
+		_controlScreen[offset] = control;
+}
+
+// This will just change a pixel directly on displayscreen. Its supposed to get 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 SciGuiScreen::putPixelOnDisplay(int x, int y, byte color) {
+	int offset = y * _width + x;
+	_displayScreen[offset] = color;
+}
+
+// Sierra's Bresenham line drawing
+// WARNING: Do not just blindly replace this with Graphics::drawLine(), as it seems to create issues with flood fill
+void SciGuiScreen::drawLine(Common::Point startPoint, Common::Point endPoint, byte color, byte priority, byte control) {
+	int16 left = startPoint.x;
+	int16 top = startPoint.y;
+	int16 right = endPoint.x;
+	int16 bottom = endPoint.y;
+
+	//set_drawing_flag
+	byte drawMask = getDrawingMask(color, priority, control);
+
+	// horizontal line
+	if (top == bottom) {
+		if (right < left)
+			SWAP(right, left);
+		for (int i = left; i <= right; i++)
+			putPixel(i, top, drawMask, color, priority, control);
+		return;
+	}
+	// vertical line
+	if (left == right) {
+		if (top > bottom)
+			SWAP(top, bottom);
+		for (int i = top; i <= bottom; i++)
+			putPixel(left, i, drawMask, color, priority, control);
+		return;
+	}
+	// sloped line - draw with Bresenham algorithm
+	int dy = bottom - top;
+	int dx = right - left;
+	int stepy = dy < 0 ? -1 : 1;
+	int stepx = dx < 0 ? -1 : 1;
+	dy = ABS(dy) << 1;
+	dx = ABS(dx) << 1;
+
+	// setting the 1st and last pixel
+	putPixel(left, top, drawMask, color, priority, control);
+	putPixel(right, bottom, drawMask, color, priority, control);
+	// drawing the line
+	if (dx > dy) { // going horizontal
+		int fraction = dy - (dx >> 1);
+		while (left != right) {
+			if (fraction >= 0) {
+				top += stepy;
+				fraction -= dx;
+			}
+			left += stepx;
+			fraction += dy;
+			putPixel(left, top, drawMask, color, priority, control);
+		}
+	} else { // going vertical
+		int fraction = dx - (dy >> 1);
+		while (top != bottom) {
+			if (fraction >= 0) {
+				left += stepx;
+				fraction -= dy;
+			}
+			top += stepy;
+			fraction += dx;
+			putPixel(left, top, drawMask, color, priority, control);
+		}
+	}
+}
+
+byte SciGuiScreen::getVisual(int x, int y) {
+	return _visualScreen[y * _width + x];
+}
+
+byte SciGuiScreen::getPriority(int x, int y) {
+	return _priorityScreen[y * _width + x];
+}
+
+byte SciGuiScreen::getControl(int x, int y) {
+	return _controlScreen[y * _width + x];
+}
+
+byte SciGuiScreen::isFillMatch(int16 x, int16 y, byte screenMask, byte t_color, byte t_pri, byte t_con) {
+	int offset = y * _width + x;
+	byte match = 0;
+
+	if (screenMask & SCI_SCREEN_MASK_VISUAL && *(_visualScreen + offset) == t_color)
+		match |= SCI_SCREEN_MASK_VISUAL;
+	if (screenMask & SCI_SCREEN_MASK_PRIORITY && *(_priorityScreen + offset) == t_pri)
+		match |= SCI_SCREEN_MASK_PRIORITY;
+	if (screenMask & SCI_SCREEN_MASK_CONTROL && *(_controlScreen + offset) == t_con)
+		match |= SCI_SCREEN_MASK_CONTROL;
+	return match;
+}
+
+int SciGuiScreen::bitsGetDataSize(Common::Rect rect, byte mask) {
+	int byteCount = sizeof(rect) + sizeof(mask);
+	int pixels = rect.width() * rect.height();
+	if (mask & SCI_SCREEN_MASK_VISUAL) {
+		byteCount += pixels; // _visualScreen
+		if (!_upscaledHires) {
+			byteCount += pixels; // _displayScreen
+		} else {
+			byteCount += pixels * 4; // _displayScreen (upscaled hires)
+		}
+	}
+	if (mask & SCI_SCREEN_MASK_PRIORITY) {
+		byteCount += pixels; // _priorityScreen
+	}
+	if (mask & SCI_SCREEN_MASK_CONTROL) {
+		byteCount += pixels; // _controlScreen
+	}
+	if (mask & SCI_SCREEN_MASK_DISPLAY) {
+		if (!_upscaledHires)
+			error("bitsGetDataSize() called w/o being in upscaled hires mode");
+		byteCount += pixels; // _displayScreen (coordinates actually are given to us for hires displayScreen)
+	}
+
+	return byteCount;
+}
+
+void SciGuiScreen::bitsSave(Common::Rect rect, byte mask, byte *memoryPtr) {
+	memcpy(memoryPtr, (void *)&rect, sizeof(rect)); memoryPtr += sizeof(rect);
+	memcpy(memoryPtr, (void *)&mask, sizeof(mask)); memoryPtr += sizeof(mask);
+
+	if (mask & SCI_SCREEN_MASK_VISUAL) {
+		bitsSaveScreen(rect, _visualScreen, memoryPtr);
+		bitsSaveDisplayScreen(rect, memoryPtr);
+	}
+	if (mask & SCI_SCREEN_MASK_PRIORITY) {
+		bitsSaveScreen(rect, _priorityScreen, memoryPtr);
+	}
+	if (mask & SCI_SCREEN_MASK_CONTROL) {
+		bitsSaveScreen(rect, _controlScreen, memoryPtr);
+	}
+	if (mask & SCI_SCREEN_MASK_DISPLAY) {
+		if (!_upscaledHires)
+			error("bitsSave() called w/o being in upscaled hires mode");
+		bitsSaveScreen(rect, _displayScreen, memoryPtr);
+	}
+}
+
+void SciGuiScreen::bitsSaveScreen(Common::Rect rect, byte *screen, byte *&memoryPtr) {
+	int width = rect.width();
+	int y;
+
+	screen += (rect.top * _width) + rect.left;
+
+	for (y = rect.top; y < rect.bottom; y++) {
+		memcpy(memoryPtr, (void*)screen, width); memoryPtr += width;
+		screen += _width;
+	}
+}
+
+void SciGuiScreen::bitsSaveDisplayScreen(Common::Rect rect, byte *&memoryPtr) {
+	byte *screen = _displayScreen;
+	int width = rect.width();
+	int y;
+
+	if (!_upscaledHires) {
+		screen += (rect.top * _displayWidth) + rect.left;
+	} else {
+		screen += (rect.top * 2 * _displayWidth) + rect.left * 2;
+		width *= 2;
+		rect.top *= 2; rect.bottom *= 2;
+	}
+
+	for (y = rect.top; y < rect.bottom; y++) {
+		memcpy(memoryPtr, (void*)screen, width); memoryPtr += width;
+		screen += _displayWidth;
+	}
+}
+
+void SciGuiScreen::bitsGetRect(byte *memoryPtr, Common::Rect *destRect) {
+	memcpy((void *)destRect, memoryPtr, sizeof(Common::Rect));
+}
+
+void SciGuiScreen::bitsRestore(byte *memoryPtr) {
+	Common::Rect rect;
+	byte mask;
+
+	memcpy((void *)&rect, memoryPtr, sizeof(rect)); memoryPtr += sizeof(rect);
+	memcpy((void *)&mask, memoryPtr, sizeof(mask)); memoryPtr += sizeof(mask);
+
+	if (mask & SCI_SCREEN_MASK_VISUAL) {
+		bitsRestoreScreen(rect, memoryPtr, _visualScreen);
+		bitsRestoreDisplayScreen(rect, memoryPtr);
+	}
+	if (mask & SCI_SCREEN_MASK_PRIORITY) {
+		bitsRestoreScreen(rect, memoryPtr, _priorityScreen);
+	}
+	if (mask & SCI_SCREEN_MASK_CONTROL) {
+		bitsRestoreScreen(rect, memoryPtr, _controlScreen);
+	}
+	if (mask & SCI_SCREEN_MASK_DISPLAY) {
+		if (!_upscaledHires)
+			error("bitsRestore() called w/o being in upscaled hires mode");
+		bitsRestoreScreen(rect, memoryPtr, _displayScreen);
+	}
+}
+
+void SciGuiScreen::bitsRestoreScreen(Common::Rect rect, byte *&memoryPtr, byte *screen) {
+	int width = rect.width();
+	int y;
+
+	screen += (rect.top * _width) + rect.left;
+
+	for (y = rect.top; y < rect.bottom; y++) {
+		memcpy((void*) screen, memoryPtr, width); memoryPtr += width;
+		screen += _width;
+	}
+}
+
+void SciGuiScreen::bitsRestoreDisplayScreen(Common::Rect rect, byte *&memoryPtr) {
+	byte *screen = _displayScreen;
+	int width = rect.width();
+	int y;
+
+	if (!_upscaledHires) {
+		screen += (rect.top * _displayWidth) + rect.left;
+	} else {
+		screen += (rect.top * 2 * _displayWidth) + rect.left * 2;
+		width *= 2;
+		rect.top *= 2; rect.bottom *= 2;
+	}
+
+	for (y = rect.top; y < rect.bottom; y++) {
+		memcpy((void*) screen, memoryPtr, width); memoryPtr += width;
+		screen += _displayWidth;
+	}
+}
+
+void SciGuiScreen::setPalette(GuiPalette*pal) {
+	// just copy palette to system
+	byte bpal[4 * 256];
+	// Get current palette, update it and put back
+	g_system->grabPalette(bpal, 0, 256);
+	for (int16 i = 0; i < 256; i++) {
+		if (!pal->colors[i].used)
+			continue;
+		bpal[i * 4] = pal->colors[i].r * pal->intensity[i] / 100;
+		bpal[i * 4 + 1] = pal->colors[i].g * pal->intensity[i] / 100;
+		bpal[i * 4 + 2] = pal->colors[i].b * pal->intensity[i] / 100;
+		bpal[i * 4 + 3] = 100;
+	}
+	g_system->setPalette(bpal, 0, 256);
+}
+
+void SciGuiScreen::setVerticalShakePos(uint16 shakePos) {
+	if (!_upscaledHires)
+		g_system->setShakePos(shakePos);
+	else
+		g_system->setShakePos(shakePos * 2);
+}
+
+void SciGuiScreen::dither(bool addToFlag) {
+	int y, x;
+	byte color, ditheredColor;
+	byte *visualPtr = _visualScreen;
+	byte *displayPtr = _displayScreen;
+
+	if (!_unditherState) {
+		// Do dithering on visual and display-screen
+		for (y = 0; y < _height; y++) {
+			for (x = 0; x < _width; x++) {
+				color = *visualPtr;
+				if (color & 0xF0) {
+					color ^= color << 4;
+					color = ((x^y) & 1) ? color >> 4 : color & 0x0F;
+					*displayPtr = color;
+					if (_upscaledHires) {
+						*(displayPtr + 1) = color;
+						*(displayPtr + _displayWidth) = color;
+						*(displayPtr + _displayWidth + 1) = color;
+					}
+					*visualPtr = color;
+				}
+				visualPtr++; displayPtr++;
+				if (_upscaledHires)
+					displayPtr++;
+			}
+			if (_upscaledHires)
+				displayPtr += _displayWidth;
+		}
+	} else {
+		if (!addToFlag)
+			memset(&_unditherMemorial, 0, sizeof(_unditherMemorial));
+		// Do dithering on visual screen and put decoded but undithered byte onto display-screen
+		for (y = 0; y < _height; y++) {
+			for (x = 0; x < _width; x++) {
+				color = *visualPtr;
+				if (color & 0xF0) {
+					color ^= color << 4;
+					// remember dither combination for cel-undithering
+					_unditherMemorial[color]++;
+					// if decoded color wants do dither with black on left side, we turn it around
+					//  otherwise the normal ega color would get used for display
+					if (color & 0xF0) {
+						ditheredColor = color;
+					}	else {
+						ditheredColor = color << 4;
+					}
+					*displayPtr = ditheredColor;
+					if (_upscaledHires) {
+						*(displayPtr + 1) = ditheredColor;
+						*(displayPtr + _displayWidth) = ditheredColor;
+						*(displayPtr + _displayWidth + 1) = ditheredColor;
+					}
+					color = ((x^y) & 1) ? color >> 4 : color & 0x0F;
+					*visualPtr = color;
+				}
+				visualPtr++; displayPtr++;
+				if (_upscaledHires)
+					displayPtr++;
+			}
+			if (_upscaledHires)
+				displayPtr += _displayWidth;
+		}
+	}
+}
+
+void SciGuiScreen::unditherSetState(bool flag) {
+	_unditherState = flag;
+}
+
+int16 *SciGuiScreen::unditherGetMemorial() {
+	if (_unditherState)
+		return (int16 *)&_unditherMemorial;
+	else
+		return NULL;
+}
+
+void SciGuiScreen::debugShowMap(int mapNo) {
+	// We cannot really support changing maps when in upscaledHires mode
+	if (_upscaledHires)
+		return;
+
+	switch (mapNo) {
+	case 0:
+		_activeScreen = _visualScreen;
+		break;
+	case 1:
+		_activeScreen = _priorityScreen;
+		break;
+	case 2:
+		_activeScreen = _controlScreen;
+		break;
+	case 3:
+		_activeScreen = _displayScreen;
+		break;
+	}
+	copyToScreen();
+}
+
+void SciGuiScreen::scale2x(byte *src, byte *dst, int16 srcWidth, int16 srcHeight) {
+	int newWidth = srcWidth * 2;
+	byte *srcPtr = src;
+
+	for (int y = 0; y < srcHeight; y++) {
+		for (int x = 0; x < srcWidth; x++) {
+			int destOffset = y * 2 * newWidth + x * 2;
+			dst[destOffset] = *srcPtr;
+			dst[destOffset + 1] = *srcPtr;
+			dst[destOffset + newWidth] = *srcPtr;
+			dst[destOffset + newWidth + 1] = *srcPtr;
+			srcPtr++;
+		}
+	}
+}
+
+} // End of namespace Sci