Merged d_draw.cpp and rdwin.cpp (what little remained of them) into screen.cpp.

svn-id: r21573

1 files changed, 132 insertions, 0 deletions

diff --git a/engines/sword2/screen.cpp b/engines/sword2/screen.cpp
index 8d62d2fa8d..8ed583d242 100644
--- a/engines/sword2/screen.cpp
+++ b/engines/sword2/screen.cpp
@@ -99,6 +99,138 @@ Screen::~Screen() {
 	free(_lightMask);
 }
 
+/**
+ * @return the graphics detail setting
+ */
+
+int8 Screen::getRenderLevel() {
+	return _renderLevel;
+}
+
+void Screen::setRenderLevel(int8 level) {
+	_renderLevel = level;
+
+	switch (_renderLevel) {
+	case 0:
+		// Lowest setting: no fancy stuff
+		_renderCaps = 0;
+		break;
+	case 1:
+		// Medium-low setting: transparency-blending
+		_renderCaps = RDBLTFX_SPRITEBLEND;
+		break;
+	case 2:
+		// Medium-high setting: transparency-blending + shading
+		_renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND;
+		break;
+	case 3:
+		// Highest setting: transparency-blending + shading +
+		// edge-blending + improved stretching
+		_renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND | RDBLTFX_EDGEBLEND;
+		break;
+	}
+}
+
+/**
+ * Tell updateDisplay() that the scene needs to be completely updated.
+ */
+
+void Screen::setNeedFullRedraw() {
+	_needFullRedraw = true;
+}
+
+/**
+ * Mark an area of the screen as dirty, first generation.
+ */
+
+void Screen::markAsDirty(int16 x0, int16 y0, int16 x1, int16 y1) {
+	int16 gridX0 = x0 / CELLWIDE;
+	int16 gridY0 = y0 / CELLDEEP;
+	int16 gridX1 = x1 / CELLWIDE;
+	int16 gridY1 = y1 / CELLDEEP;
+
+	for (int16 i = gridY0; i <= gridY1; i++)
+		for (int16 j = gridX0; j <= gridX1; j++)
+			_dirtyGrid[i * _gridWide + j] = 2;
+}
+
+/**
+ * This function has two purposes: It redraws the scene, and it handles input
+ * events, palette fading, etc. It should be called at a high rate (> 20 per
+ * second), but the scene is usually only redrawn about 12 times per second,
+ * except when then screen is scrolling.
+ *
+ * @param redrawScene If true, redraw the scene.
+ */
+
+void Screen::updateDisplay(bool redrawScene) {
+	_vm->parseInputEvents();
+	fadeServer();
+
+	if (redrawScene) {
+		int i;
+
+		// Note that the entire scene is always rendered, which is less
+		// than optimal, but at least we can try to be intelligent
+		// about updating the screen afterwards.
+
+		if (_needFullRedraw) {
+			// Update the entire screen. This is necessary when
+			// scrolling, fading, etc.
+
+			_vm->_system->copyRectToScreen(_buffer + MENUDEEP * _screenWide, _screenWide, 0, MENUDEEP, _screenWide, _screenDeep - 2 * MENUDEEP);
+			_needFullRedraw = false;
+		} else {
+			// Update only the dirty areas of the screen
+
+			int j, x, y;
+			int stripWide;
+
+			for (i = 0; i < _gridDeep; i++) {
+				stripWide = 0;
+
+				for (j = 0; j < _gridWide; j++) {
+					if (_dirtyGrid[i * _gridWide + j]) {
+						stripWide++;
+					} else if (stripWide) {
+						x = CELLWIDE * (j - stripWide);
+						y = CELLDEEP * i;
+						_vm->_system->copyRectToScreen(_buffer + y * _screenWide + x, _screenWide, x, y, stripWide * CELLWIDE, CELLDEEP);
+						stripWide = 0;
+					}
+				}
+
+				if (stripWide) {
+					x = CELLWIDE * (j - stripWide);
+					y = CELLDEEP * i;
+					_vm->_system->copyRectToScreen(_buffer + y * _screenWide + x, _screenWide, x, y, stripWide * CELLWIDE, CELLDEEP);
+					stripWide = 0;
+				}
+			}
+		}
+
+		// Age the dirty cells one generation. This way we keep track
+		// of both the cells that were updated this time, and the ones
+		// that were updated the last time.
+
+		for (i = 0; i < _gridWide * _gridDeep; i++)
+			_dirtyGrid[i] >>= 1;
+	}
+
+	// We always need to update because of fades, menu animations, etc.
+	_vm->_system->updateScreen();
+}
+
+/**
+ * Fill the screen buffer with palette colour zero. Note that it does not
+ * touch the menu areas of the screen.
+ */
+
+void Screen::clearScene() {
+	memset(_buffer + MENUDEEP * _screenWide, 0, _screenWide * RENDERDEEP);
+	_needFullRedraw = true;
+}
+
 void Screen::buildDisplay() {
 	if (_thisScreen.new_palette) {
 		// start the layer palette fading up