Merge branch 'master' into hopkins

11 files changed, 475 insertions, 201 deletions

diff --git a/engines/wintermute/base/gfx/base_image.cpp b/engines/wintermute/base/gfx/base_image.cpp
index 4b15d563ed..75de95128f 100644
--- a/engines/wintermute/base/gfx/base_image.cpp
+++ b/engines/wintermute/base/gfx/base_image.cpp
@@ -43,10 +43,10 @@ namespace Wintermute {
 //////////////////////////////////////////////////////////////////////
 BaseImage::BaseImage() {
 	_fileManager = BaseFileManager::getEngineInstance();
-	_palette = NULL;
-	_surface = NULL;
-	_decoder = NULL;
-	_deletableSurface = NULL;
+	_palette = nullptr;
+	_surface = nullptr;
+	_decoder = nullptr;
+	_deletableSurface = nullptr;
 }
 
 
@@ -105,7 +105,7 @@ void BaseImage::copyFrom(const Graphics::Surface *surface) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool BaseImage::saveBMPFile(const char *filename) const {
+bool BaseImage::saveBMPFile(const Common::String &filename) const {
 	warning("BaseImage::saveBMPFile - stubbed"); // TODO
 	return false;
 }
@@ -118,7 +118,7 @@ bool BaseImage::resize(int newWidth, int newHeight) {
 	if (_deletableSurface) {
 		_deletableSurface->free();
 		delete _deletableSurface;
-		_deletableSurface = NULL;
+		_deletableSurface = nullptr;
 	}
 	_surface = _deletableSurface = temp.scale((uint16)newWidth, (uint16)newHeight);
 	temp.free();
@@ -222,7 +222,7 @@ bool BaseImage::copyFrom(BaseImage *origImage, int newWidth, int newHeight) {
 	if (_deletableSurface) {
 		_deletableSurface->free();
 		delete _deletableSurface;
-		_deletableSurface = NULL;
+		_deletableSurface = nullptr;
 	}
 	_surface = _deletableSurface = temp.scale((uint16)newWidth, (uint16)newHeight);
 	return true;
diff --git a/engines/wintermute/base/gfx/base_image.h b/engines/wintermute/base/gfx/base_image.h
index 6d01b84184..017305e5d0 100644
--- a/engines/wintermute/base/gfx/base_image.h
+++ b/engines/wintermute/base/gfx/base_image.h
@@ -55,7 +55,7 @@ public:
 	byte getAlphaAt(int x, int y) const;
 	bool writeBMPToStream(Common::WriteStream *stream) const;
 	bool resize(int newWidth, int newHeight);
-	bool saveBMPFile(const char *filename) const;
+	bool saveBMPFile(const Common::String &filename) const;
 	bool copyFrom(BaseImage *origImage, int newWidth = 0, int newHeight = 0);
 	void copyFrom(const Graphics::Surface *surface);
 private:
diff --git a/engines/wintermute/base/gfx/base_renderer.cpp b/engines/wintermute/base/gfx/base_renderer.cpp
index e7ffc14c25..c20881e425 100644
--- a/engines/wintermute/base/gfx/base_renderer.cpp
+++ b/engines/wintermute/base/gfx/base_renderer.cpp
@@ -29,6 +29,7 @@
 #include "engines/wintermute/base/base_active_rect.h"
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/base/gfx/base_surface.h"
+#include "engines/wintermute/base/gfx/base_image.h"
 #include "engines/wintermute/base/base_sub_frame.h"
 #include "engines/wintermute/base/base_region.h"
 #include "engines/wintermute/platform_osystem.h"
@@ -56,7 +57,7 @@ BaseRenderer::BaseRenderer(BaseGame *inGame) : BaseClass(inGame) {
 
 	_loadImageName = "";
 	_saveImageName = "";
-	_saveLoadImage = NULL;
+	_saveLoadImage = nullptr;
 	_loadInProgress = false;
 	_hasDrawnSaveLoadImage = false;
 
@@ -132,24 +133,24 @@ void BaseRenderer::initSaveLoad(bool isSaving, bool quickSave) {
 
 	if (isSaving && !quickSave) {
 		delete _saveLoadImage;
-		_saveLoadImage = NULL;
+		_saveLoadImage = nullptr;
 		if (_saveImageName.size()) {
 			_saveLoadImage = createSurface();
 
 			if (!_saveLoadImage || DID_FAIL(_saveLoadImage->create(_saveImageName, true, 0, 0, 0))) {
 				delete _saveLoadImage;
-				_saveLoadImage = NULL;
+				_saveLoadImage = nullptr;
 			}
 		}
 	} else {
 		delete _saveLoadImage;
-		_saveLoadImage = NULL;
+		_saveLoadImage = nullptr;
 		if (_loadImageName.size()) {
 			_saveLoadImage = createSurface();
 
 			if (!_saveLoadImage || DID_FAIL(_saveLoadImage->create(_loadImageName, true, 0, 0, 0))) {
 				delete _saveLoadImage;
-				_saveLoadImage = NULL;
+				_saveLoadImage = nullptr;
 			}
 		}
 		_loadInProgress = true;
@@ -162,7 +163,7 @@ void BaseRenderer::endSaveLoad() {
 	_indicatorWidthDrawn = 0;
 
 	delete _saveLoadImage;
-	_saveLoadImage = NULL;
+	_saveLoadImage = nullptr;
 }
 
 void BaseRenderer::persistSaveLoadImages(BasePersistenceManager *persistMgr) {
@@ -214,7 +215,7 @@ BaseObject *BaseRenderer::getObjectAt(int x, int y) {
 		}
 	}
 
-	return (BaseObject *)NULL;
+	return (BaseObject *)nullptr;
 }
 
 
@@ -317,7 +318,7 @@ bool BaseRenderer::clipCursor() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseRenderer::unclipCursor() {
 	/*
-	if (!_windowed) ::ClipCursor(NULL);
+	if (!_windowed) ::ClipCursor(nullptr);
 	*/
 	return STATUS_OK;
 }
@@ -344,6 +345,22 @@ void BaseRenderer::addRectToList(BaseActiveRect *rect) {
 	_rectList.push_back(rect);
 }
 
+bool BaseRenderer::saveScreenShot(const Common::String &filename, int sizeX, int sizeY) {
+	BaseImage *image = takeScreenshot();
+	if (image) {
+		if (sizeX != 0 && sizeY != 0) {
+			if (!DID_SUCCEED(image->resize(sizeX, sizeY))) {
+				delete image;
+				return false;
+			}
+		}
+		image->saveBMPFile(filename);
+		delete image;
+		return true;
+	}
+	return false;
+}
+
 //////////////////////////////////////////////////////////////////////////
 bool BaseRenderer::displayIndicator() {
 	if (!_indicatorDisplay || !_indicatorProgress) {
diff --git a/engines/wintermute/base/gfx/base_renderer.h b/engines/wintermute/base/gfx/base_renderer.h
index 0475824464..5a24e0179a 100644
--- a/engines/wintermute/base/gfx/base_renderer.h
+++ b/engines/wintermute/base/gfx/base_renderer.h
@@ -61,6 +61,7 @@ public:
 	 * @return a BaseImage containing the current screen-buffer.
 	 */
 	virtual BaseImage *takeScreenshot() = 0;
+	virtual bool saveScreenShot(const Common::String &filename, int sizeX = 0, int sizeY = 0);
 	virtual bool setViewport(int left, int top, int right, int bottom);
 	virtual bool setViewport(Rect32 *rect);
 	virtual Rect32 getViewPort() = 0;
@@ -81,12 +82,13 @@ public:
 	 * @param g the green component to fade too.
 	 * @param b the blue component to fade too.
 	 * @param a the alpha component to fade too.
-	 * @param rect the portion of the screen to fade (if NULL, the entire screen will be faded).
+	 * @param rect the portion of the screen to fade (if nullptr, the entire screen will be faded).
 	 */
-	virtual void fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect = NULL) = 0;
-	virtual bool drawLine(int x1, int y1, int x2, int y2, uint32 color);
-	virtual bool drawRect(int x1, int y1, int x2, int y2, uint32 color, int width = 1);
-	BaseRenderer(BaseGame *inGame = NULL);
+	virtual void fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect = nullptr) = 0;
+
+	virtual bool drawLine(int x1, int y1, int x2, int y2, uint32 color); 	// Unused outside indicator-display
+	virtual bool drawRect(int x1, int y1, int x2, int y2, uint32 color, int width = 1); 	// Unused outside indicator-display
+	BaseRenderer(BaseGame *inGame = nullptr);
 	virtual ~BaseRenderer();
 	virtual bool setProjection() {
 		return STATUS_OK;
@@ -100,7 +102,7 @@ public:
 	 * @param g the green component to fill with.
 	 * @param b the blue component to fill with.
 	 */
-	virtual bool fill(byte r, byte g, byte b, Common::Rect *rect = NULL) = 0;
+	virtual bool fill(byte r, byte g, byte b, Common::Rect *rect = nullptr) = 0;
 	virtual void onWindowChange();
 	virtual bool initRenderer(int width, int height, bool windowed);
 	/**
@@ -179,7 +181,7 @@ public:
 	void setIndicator(int width, int height, int x, int y, uint32 color);
 	void persistSaveLoadImages(BasePersistenceManager *persistMgr);
 	void initSaveLoad(bool isSaving, bool quickSave = false);
-	void endSaveLoad();
+	virtual void endSaveLoad();
 	void setLoadingScreen(const char *filename, int x, int y);
 	void setSaveImage(const char *filename, int x, int y);
 
diff --git a/engines/wintermute/base/gfx/base_surface.h b/engines/wintermute/base/gfx/base_surface.h
index ee53c03e77..1ada900161 100644
--- a/engines/wintermute/base/gfx/base_surface.h
+++ b/engines/wintermute/base/gfx/base_surface.h
@@ -55,6 +55,7 @@ public:
 	virtual bool display(int x, int y, Rect32 rect, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) = 0;
 	virtual bool displayZoom(int x, int y, Rect32 rect, float zoomX, float zoomY, uint32 alpha = 0xFFFFFFFF, bool transparent = false, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) = 0;
 	virtual bool displayTransform(int x, int y, int hotX, int hotY, Rect32 rect, float zoomX, float zoomY, uint32 alpha, float rotate, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) = 0;
+	virtual bool repeatLastDisplayOp(int offsetX, int offsetY, int numTimesX, int numTimesY) = 0;
 	virtual bool restore();
 	virtual bool create(const Common::String &filename, bool defaultCK, byte ckRed, byte ckGreen, byte ckBlue, int lifeTime = -1, bool keepLoaded = false) = 0;
 	virtual bool create(int width, int height);
@@ -62,7 +63,7 @@ public:
 		return STATUS_FAILED;
 	}
 	virtual bool putPixel(int x, int y, byte r, byte g, byte b, int a = -1);
-	virtual bool getPixel(int x, int y, byte *r, byte *g, byte *b, byte *a = NULL);
+	virtual bool getPixel(int x, int y, byte *r, byte *g, byte *b, byte *a = nullptr);
 	virtual bool comparePixel(int x, int y, byte r, byte g, byte b, int a = -1);
 	virtual bool startPixelOp();
 	virtual bool endPixelOp();
@@ -79,7 +80,7 @@ public:
 	}
 	Common::String getFileNameStr() { return _filename; }
 	const char* getFileName() { return _filename.c_str(); }
-	//void SetWidth(int Width){ _width = Width;    }
+	//void SetWidth(int Width) { _width = Width;    }
 	//void SetHeight(int Height){ _height = Height; }
 protected:
 	bool _ckDefault;
diff --git a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
index 7970a25300..061f52776e 100644
--- a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
+++ b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
@@ -28,6 +28,7 @@
 
 #include "engines/wintermute/base/gfx/osystem/base_render_osystem.h"
 #include "engines/wintermute/base/gfx/osystem/base_surface_osystem.h"
+#include "engines/wintermute/base/gfx/osystem/render_ticket.h"
 #include "engines/wintermute/base/base_surface_storage.h"
 #include "engines/wintermute/base/gfx/base_image.h"
 #include "engines/wintermute/math/math_util.h"
@@ -40,56 +41,6 @@
 
 namespace Wintermute {
 
-RenderTicket::RenderTicket(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, bool mirrorX, bool mirrorY, bool disableAlpha) : _owner(owner),
-	_srcRect(*srcRect), _dstRect(*dstRect), _drawNum(0), _isValid(true), _wantsDraw(true), _hasAlpha(!disableAlpha) {
-	_colorMod = 0;
-	_mirror = TransparentSurface::FLIP_NONE;
-	if (mirrorX) {
-		_mirror |= TransparentSurface::FLIP_V;
-	}
-	if (mirrorY) {
-		_mirror |= TransparentSurface::FLIP_H;
-	}
-	if (surf) {
-		_surface = new Graphics::Surface();
-		_surface->create((uint16)srcRect->width(), (uint16)srcRect->height(), surf->format);
-		assert(_surface->format.bytesPerPixel == 4);
-		// Get a clipped copy of the surface
-		for (int i = 0; i < _surface->h; i++) {
-			memcpy(_surface->getBasePtr(0, i), surf->getBasePtr(srcRect->left, srcRect->top + i), srcRect->width() * _surface->format.bytesPerPixel);
-		}
-		// Then scale it if necessary
-		if (dstRect->width() != srcRect->width() || dstRect->height() != srcRect->height()) {
-			TransparentSurface src(*_surface, false);
-			Graphics::Surface *temp = src.scale(dstRect->width(), dstRect->height());
-			_surface->free();
-			delete _surface;
-			_surface = temp;
-		}
-	} else {
-		_surface = NULL;
-	}
-}
-
-RenderTicket::~RenderTicket() {
-	if (_surface) {
-		_surface->free();
-		delete _surface;
-	}
-}
-
-bool RenderTicket::operator==(RenderTicket &t) {
-	if ((t._srcRect != _srcRect) ||
-	        (t._dstRect != _dstRect) ||
-	        (t._mirror != _mirror) ||
-	        (t._owner != _owner) ||
-	        (t._hasAlpha != _hasAlpha) ||
-	        (t._colorMod != _colorMod)) {
-		return false;
-	}
-	return true;
-}
-
 BaseRenderer *makeOSystemRenderer(BaseGame *inGame) {
 	return new BaseRenderOSystem(inGame);
 }
@@ -100,16 +51,33 @@ BaseRenderOSystem::BaseRenderOSystem(BaseGame *inGame) : BaseRenderer(inGame) {
 	_blankSurface = new Graphics::Surface();
 	_drawNum = 1;
 	_needsFlip = true;
+	_spriteBatch = false;
+	_batchNum = 0;
+	_skipThisFrame = false;
+	_previousTicket = nullptr;
 
 	_borderLeft = _borderRight = _borderTop = _borderBottom = 0;
 	_ratioX = _ratioY = 1.0f;
 	setAlphaMod(255);
 	setColorMod(255, 255, 255);
-	_dirtyRect = NULL;
+	_dirtyRect = nullptr;
+	_disableDirtyRects = false;
+	if (ConfMan.hasKey("dirty_rects")) {
+		_disableDirtyRects = !ConfMan.getBool("dirty_rects");
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////
 BaseRenderOSystem::~BaseRenderOSystem() {
+	RenderQueueIterator it = _renderQueue.begin();
+	while (it != _renderQueue.end()) {
+		RenderTicket *ticket = *it;
+		it = _renderQueue.erase(it);
+		delete ticket;
+	}
+
+	delete _dirtyRect;
+
 	_renderSurface->free();
 	delete _renderSurface;
 	_blankSurface->free();
@@ -198,6 +166,14 @@ bool BaseRenderOSystem::indicatorFlip() {
 }
 
 bool BaseRenderOSystem::flip() {
+	if (_skipThisFrame) {
+		_skipThisFrame = false;
+		delete _dirtyRect;
+		_dirtyRect = nullptr;
+		g_system->updateScreen();
+		_needsFlip = false;
+		return true;
+	}
 	if (!_disableDirtyRects) {
 		drawTickets();
 	} else {
@@ -220,7 +196,7 @@ bool BaseRenderOSystem::flip() {
 		}
 		//  g_system->copyRectToScreen((byte *)_renderSurface->pixels, _renderSurface->pitch, _dirtyRect->left, _dirtyRect->top, _dirtyRect->width(), _dirtyRect->height());
 		delete _dirtyRect;
-		_dirtyRect = NULL;
+		_dirtyRect = nullptr;
 		g_system->updateScreen();
 		_needsFlip = false;
 	}
@@ -259,14 +235,6 @@ void BaseRenderOSystem::fade(uint16 alpha) {
 
 //////////////////////////////////////////////////////////////////////////
 void BaseRenderOSystem::fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect) {
-	// This particular warning is rather messy, as this function is called a ton,
-	// thus we avoid printing it more than once.
-
-	// TODO: Add fading with dirty rects.
-	if (!_disableDirtyRects) {
-		warning("BaseRenderOSystem::FadeToColor - Breaks when using dirty rects");
-	}
-
 	Common::Rect fillRect;
 
 	if (rect) {
@@ -294,7 +262,7 @@ void BaseRenderOSystem::fadeToColor(byte r, byte g, byte b, byte a, Common::Rect
 	Common::Rect sizeRect(fillRect);
 	sizeRect.translate(-fillRect.top, -fillRect.left);
 	surf.fillRect(fillRect, col);
-	drawSurface(NULL, &surf, &sizeRect, &fillRect, false, false);
+	drawSurface(nullptr, &surf, &sizeRect, &fillRect, false, false);
 	surf.free();
 
 	//SDL_SetRenderDrawColor(_renderer, r, g, b, a);
@@ -307,22 +275,38 @@ Graphics::PixelFormat BaseRenderOSystem::getPixelFormat() const {
 }
 
 void BaseRenderOSystem::drawSurface(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, bool mirrorX, bool mirrorY, bool disableAlpha) {
+	// Start searching from the beginning for the first and second items (since it's empty the first time around
+	// then keep incrementing the start-position, to avoid comparing against already used tickets.
+	if (_drawNum == 0 || _drawNum == 1) {
+		_lastAddedTicket = _renderQueue.begin();
+	}
+
 	// Skip rects that are completely outside the screen:
 	if ((dstRect->left < 0 && dstRect->right < 0) || (dstRect->top < 0 && dstRect->bottom < 0)) {
 		return;
 	}
 
 	if (owner) { // Fade-tickets are owner-less
-		RenderTicket compare(owner, NULL, srcRect, dstRect, mirrorX, mirrorY, disableAlpha);
+		RenderTicket compare(owner, nullptr, srcRect, dstRect, mirrorX, mirrorY, disableAlpha);
+		compare._batchNum = _batchNum;
+		if (_spriteBatch) {
+			_batchNum++;
+		}
 		compare._colorMod = _colorMod;
 		RenderQueueIterator it;
-		for (it = _renderQueue.begin(); it != _renderQueue.end(); ++it) {
-			if ((*it)->_owner == owner && *(*it) == compare && (*it)->_isValid) {
-				(*it)->_colorMod = _colorMod;
+		// Avoid calling end() and operator* every time, when potentially going through
+		// LOTS of tickets.
+		RenderQueueIterator endIterator = _renderQueue.end();
+		RenderTicket *compareTicket = nullptr;
+		for (it = _lastAddedTicket; it != endIterator; ++it) {
+			compareTicket = *it;
+			if (*(compareTicket) == compare && compareTicket->_isValid) {
+				compareTicket->_colorMod = _colorMod;
 				if (_disableDirtyRects) {
-					drawFromSurface(*it, NULL);
+					drawFromSurface(compareTicket);
 				} else {
-					drawFromTicket(*it);
+					drawFromTicket(compareTicket);
+					_previousTicket = compareTicket;
 				}
 				return;
 			}
@@ -332,10 +316,50 @@ void BaseRenderOSystem::drawSurface(BaseSurfaceOSystem *owner, const Graphics::S
 	ticket->_colorMod = _colorMod;
 	if (!_disableDirtyRects) {
 		drawFromTicket(ticket);
+		_previousTicket = ticket;
 	} else {
 		ticket->_wantsDraw = true;
 		_renderQueue.push_back(ticket);
-		drawFromSurface(ticket, NULL);
+	}
+}
+
+void BaseRenderOSystem::repeatLastDraw(int offsetX, int offsetY, int numTimesX, int numTimesY) {
+	if (_previousTicket && _lastAddedTicket != _renderQueue.end()) {
+		RenderTicket *origTicket = _previousTicket;
+
+		// Make sure drawSurface WILL start from the correct _lastAddedTicket
+		if (*_lastAddedTicket != origTicket) {
+			RenderQueueIterator it;
+			RenderQueueIterator endIterator = _renderQueue.end();
+			for (it = _renderQueue.begin(); it != endIterator; ++it) {
+				if ((*it) == _previousTicket) {
+					_lastAddedTicket = it;
+					break;
+				}
+			}
+		}
+		Common::Rect srcRect(0, 0, 0, 0);
+		srcRect.setWidth(origTicket->getSrcRect()->width());
+		srcRect.setHeight(origTicket->getSrcRect()->height());
+
+		Common::Rect dstRect = origTicket->_dstRect;
+		int initLeft = dstRect.left;
+		int initRight = dstRect.right;
+
+		for (int i = 0; i < numTimesY; i++) {
+			if (i == 0) {
+				dstRect.translate(offsetX, 0);
+			}
+			for (int j = (i == 0 ? 1 : 0); j < numTimesX; j++) {
+				drawSurface(origTicket->_owner, origTicket->getSurface(), &srcRect, &dstRect, false, false);
+				dstRect.translate(offsetX, 0);
+			}
+			dstRect.left = initLeft;
+			dstRect.right = initRight;
+			dstRect.translate(0, offsetY);
+		}
+	} else {
+		error("Repeat-draw failed (did you forget to draw something before this?)");
 	}
 }
 
@@ -363,28 +387,31 @@ void BaseRenderOSystem::drawFromTicket(RenderTicket *renderTicket) {
 			renderTicket->_drawNum = _drawNum++;
 			_renderQueue.push_back(renderTicket);
 			addDirtyRect(renderTicket->_dstRect);
+			++_lastAddedTicket;
 		} else {
 			// Before something
-			Common::List<RenderTicket *>::iterator pos;
+			RenderQueueIterator pos;
 			for (pos = _renderQueue.begin(); pos != _renderQueue.end(); pos++) {
 				if ((*pos)->_drawNum >= _drawNum) {
 					break;
 				}
 			}
 			_renderQueue.insert(pos, renderTicket);
-			Common::List<RenderTicket *>::iterator it;
 			renderTicket->_drawNum = _drawNum++;
 			// Increment the following tickets, so they still are in line
+			RenderQueueIterator it;
 			for (it = pos; it != _renderQueue.end(); ++it) {
 				(*it)->_drawNum++;
 				(*it)->_wantsDraw = false;
 			}
 			addDirtyRect(renderTicket->_dstRect);
+			_lastAddedTicket = pos;
 		}
 	} else {
 		// Was drawn last round, still in the same order
 		if (_drawNum == renderTicket->_drawNum) {
 			_drawNum++;
+			++_lastAddedTicket;
 		} else {
 			// Remove the ticket from the list
 			RenderQueueIterator it = _renderQueue.begin();
@@ -421,9 +448,12 @@ void BaseRenderOSystem::addDirtyRect(const Common::Rect &rect) {
 void BaseRenderOSystem::drawTickets() {
 	RenderQueueIterator it = _renderQueue.begin();
 	// Clean out the old tickets
-	int decrement = 0;
+	// Note: We draw invalid tickets too, otherwise we wouldn't be honouring
+	// the draw request they obviously made BEFORE becoming invalid, either way
+	// we have a copy of their data, so their invalidness won't affect us.
+	uint32 decrement = 0;
 	while (it != _renderQueue.end()) {
-		if ((*it)->_wantsDraw == false || (*it)->_isValid == false) {
+		if ((*it)->_wantsDraw == false) {
 			RenderTicket *ticket = *it;
 			addDirtyRect((*it)->_dstRect);
 			it = _renderQueue.erase(it);
@@ -435,6 +465,12 @@ void BaseRenderOSystem::drawTickets() {
 		}
 	}
 	if (!_dirtyRect || _dirtyRect->width() == 0 || _dirtyRect->height() == 0) {
+		it = _renderQueue.begin();
+		while (it != _renderQueue.end()) {
+			RenderTicket *ticket = *it;
+			ticket->_wantsDraw = false;
+			++it;
+		}
 		return;
 	}
 	// The color-mods are stored in the RenderTickets on add, since we set that state again during
@@ -447,7 +483,7 @@ void BaseRenderOSystem::drawTickets() {
 	for (it = _renderQueue.begin(); it != _renderQueue.end(); ++it) {
 		RenderTicket *ticket = *it;
 		assert(ticket->_drawNum == _drawNum++);
-		if (ticket->_isValid && ticket->_dstRect.intersects(*_dirtyRect)) {
+		if (ticket->_dstRect.intersects(*_dirtyRect)) {
 			// dstClip is the area we want redrawn.
 			Common::Rect dstClip(ticket->_dstRect);
 			// reduce it to the dirty rect
@@ -460,7 +496,7 @@ void BaseRenderOSystem::drawTickets() {
 			dstClip.translate(-offsetX, -offsetY);
 
 			_colorMod = ticket->_colorMod;
-			drawFromSurface(ticket->getSurface(), &ticket->_srcRect, &pos, &dstClip, ticket->_mirror);
+			drawFromSurface(ticket, &pos, &dstClip);
 			_needsFlip = true;
 		}
 		// Some tickets want redraw but don't actually clip the dirty area (typically the ones that shouldnt become clear-color)
@@ -470,46 +506,40 @@ void BaseRenderOSystem::drawTickets() {
 
 	// Revert the colorMod-state.
 	_colorMod = oldColorMod;
+	
+	it = _renderQueue.begin();
+	// Clean out the old tickets
+	decrement = 0;
+	while (it != _renderQueue.end()) {
+		if ((*it)->_isValid == false) {
+			RenderTicket *ticket = *it;
+			addDirtyRect((*it)->_dstRect);
+			it = _renderQueue.erase(it);
+			delete ticket;
+			decrement++;
+		} else {
+			(*it)->_drawNum -= decrement;
+			++it;
+		}
+	}
+
 }
 
 // Replacement for SDL2's SDL_RenderCopy
-void BaseRenderOSystem::drawFromSurface(RenderTicket *ticket, Common::Rect *clipRect) {
-	TransparentSurface src(*ticket->getSurface(), false);
-	bool doDelete = false;
-	if (!clipRect) {
-		doDelete = true;
-		clipRect = new Common::Rect();
-		clipRect->setWidth(ticket->getSurface()->w);
-		clipRect->setHeight(ticket->getSurface()->h);
-	}
-
-	src._enableAlphaBlit = ticket->_hasAlpha;
-	src.blit(*_renderSurface, ticket->_dstRect.left, ticket->_dstRect.top, ticket->_mirror, clipRect, _colorMod, clipRect->width(), clipRect->height());
-	if (doDelete) {
-		delete clipRect;
-	}
+void BaseRenderOSystem::drawFromSurface(RenderTicket *ticket) {
+	ticket->drawToSurface(_renderSurface);
 }
-void BaseRenderOSystem::drawFromSurface(const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, Common::Rect *clipRect, uint32 mirror) {
-	TransparentSurface src(*surf, false);
-	bool doDelete = false;
-	if (!clipRect) {
-		doDelete = true;
-		clipRect = new Common::Rect();
-		clipRect->setWidth(surf->w);
-		clipRect->setHeight(surf->h);
-	}
 
-	src.blit(*_renderSurface, dstRect->left, dstRect->top, mirror, clipRect, _colorMod, clipRect->width(), clipRect->height());
-	if (doDelete) {
-		delete clipRect;
-	}
+void BaseRenderOSystem::drawFromSurface(RenderTicket *ticket, Common::Rect *dstRect, Common::Rect *clipRect) {
+	ticket->drawToSurface(_renderSurface, dstRect, clipRect);
 }
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseRenderOSystem::drawLine(int x1, int y1, int x2, int y2, uint32 color) {
-
-	if (!_disableDirtyRects) {
-		warning("BaseRenderOSystem::DrawLine - doesn't work for dirty rects yet");
+	// This function isn't used outside of indicator-displaying, and thus quite unused in
+	// BaseRenderOSystem when dirty-rects are enabled.
+	if (!_disableDirtyRects && !_indicatorDisplay) {
+		error("BaseRenderOSystem::DrawLine - doesn't work for dirty rects yet");
 	}
 
 	byte r = RGBCOLGetR(color);
@@ -606,4 +636,36 @@ BaseSurface *BaseRenderOSystem::createSurface() {
 	return new BaseSurfaceOSystem(_gameRef);
 }
 
+void BaseRenderOSystem::endSaveLoad() {
+	BaseRenderer::endSaveLoad();
+
+	// Clear the scale-buffered tickets as we just loaded.
+	RenderQueueIterator it = _renderQueue.begin();
+	while (it != _renderQueue.end()) {
+		RenderTicket *ticket = *it;
+		it = _renderQueue.erase(it);
+		delete ticket;
+	}
+	// HACK: After a save the buffer will be drawn before the scripts get to update it,
+	// so just skip this single frame.
+	_skipThisFrame = true;
+	_drawNum = 1;
+
+	_renderSurface->fillRect(Common::Rect(0, 0, _renderSurface->h, _renderSurface->w), _renderSurface->format.ARGBToColor(255, 0, 0, 0));
+	g_system->copyRectToScreen((byte *)_renderSurface->pixels, _renderSurface->pitch, 0, 0, _renderSurface->w, _renderSurface->h);
+	g_system->updateScreen();
+}
+
+bool BaseRenderOSystem::startSpriteBatch() {
+	_spriteBatch = true;
+	_batchNum = 1;
+	return STATUS_OK;
+}
+
+bool BaseRenderOSystem::endSpriteBatch() {
+	_spriteBatch = false;
+	_batchNum = 0;
+	return STATUS_OK;
+}
+
 } // end of namespace Wintermute
diff --git a/engines/wintermute/base/gfx/osystem/base_render_osystem.h b/engines/wintermute/base/gfx/osystem/base_render_osystem.h
index 1e72508cd0..cc2ed57f9b 100644
--- a/engines/wintermute/base/gfx/osystem/base_render_osystem.h
+++ b/engines/wintermute/base/gfx/osystem/base_render_osystem.h
@@ -36,27 +36,7 @@
 
 namespace Wintermute {
 class BaseSurfaceOSystem;
-class RenderTicket {
-	Graphics::Surface *_surface;
-public:
-	RenderTicket(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRest, bool mirrorX = false, bool mirrorY = false, bool disableAlpha = false);
-	RenderTicket() : _isValid(true), _wantsDraw(false), _drawNum(0) {}
-	~RenderTicket();
-	const Graphics::Surface *getSurface() { return _surface; }
-	Common::Rect _srcRect;
-	Common::Rect _dstRect;
-	uint32 _mirror;
-	bool _hasAlpha;
-
-	bool _isValid;
-	bool _wantsDraw;
-	uint32 _drawNum;
-	uint32 _colorMod;
-
-	BaseSurfaceOSystem *_owner;
-	bool operator==(RenderTicket &a);
-};
-
+class RenderTicket;
 class BaseRenderOSystem : public BaseRenderer {
 public:
 	BaseRenderOSystem(BaseGame *inGame);
@@ -64,17 +44,17 @@ public:
 
 	Common::String getName() const;
 
-	bool initRenderer(int width, int height, bool windowed);
-	bool flip();
+	bool initRenderer(int width, int height, bool windowed) override;
+	bool flip() override;
 	virtual bool indicatorFlip();
-	bool fill(byte r, byte g, byte b, Common::Rect *rect = NULL);
-	Graphics::PixelFormat getPixelFormat() const;
-	void fade(uint16 alpha);
-	void fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect = NULL);
+	bool fill(byte r, byte g, byte b, Common::Rect *rect = nullptr) override;
+	Graphics::PixelFormat getPixelFormat() const override;
+	void fade(uint16 alpha) override;
+	void fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect = nullptr) override;
 
-	bool drawLine(int x1, int y1, int x2, int y2, uint32 color);
+	bool drawLine(int x1, int y1, int x2, int y2, uint32 color) override;
 
-	BaseImage *takeScreenshot();
+	BaseImage *takeScreenshot() override;
 
 	void setAlphaMod(byte alpha);
 	void setColorMod(byte r, byte g, byte b);
@@ -82,32 +62,40 @@ public:
 	void invalidateTicketsFromSurface(BaseSurfaceOSystem *surf);
 	void drawFromTicket(RenderTicket *renderTicket);
 
-	bool setViewport(int left, int top, int right, int bottom);
-	bool setViewport(Rect32 *rect) { return BaseRenderer::setViewport(rect); }
-	Rect32 getViewPort();
+	bool setViewport(int left, int top, int right, int bottom) override;
+	bool setViewport(Rect32 *rect) override { return BaseRenderer::setViewport(rect); }
+	Rect32 getViewPort() override;
 	void modTargetRect(Common::Rect *rect);
-	void pointFromScreen(Point32 *point);
+	void pointFromScreen(Point32 *point) ;
 	void pointToScreen(Point32 *point);
 
-	void dumpData(const char *filename);
+	void dumpData(const char *filename) override;
 
-	float getScaleRatioX() const {
+	float getScaleRatioX() const override {
 		return _ratioX;
 	}
-	float getScaleRatioY() const {
+	float getScaleRatioY() const override {
 		return _ratioY;
 	}
-
-	void drawSurface(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, bool mirrorX, bool mirrorY, bool disableAlpha = false);
-	BaseSurface *createSurface();
+	virtual bool startSpriteBatch() override;
+	virtual bool endSpriteBatch() override;
+	void endSaveLoad();
+	void drawSurface(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, bool mirrorX, bool mirrorY, bool disableAlpha = false) ;
+	void repeatLastDraw(int offsetX, int offsetY, int numTimesX, int numTimesY);
+	BaseSurface *createSurface() override;
 private:
-	void addDirtyRect(const Common::Rect &rect);
+	void addDirtyRect(const Common::Rect &rect) ;
 	void drawTickets();
-	void drawFromSurface(RenderTicket *ticket, Common::Rect *clipRect);
-	void drawFromSurface(const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, Common::Rect *clipRect, uint32 mirror);
+	// Non-dirty-rects:
+	void drawFromSurface(RenderTicket *ticket);
+	// Dirty-rects:
+	void drawFromSurface(RenderTicket *ticket, Common::Rect *dstRect, Common::Rect *clipRect);
 	typedef Common::List<RenderTicket *>::iterator RenderQueueIterator;
 	Common::Rect *_dirtyRect;
 	Common::List<RenderTicket *> _renderQueue;
+	RenderQueueIterator _lastAddedTicket;
+	RenderTicket *_previousTicket;
+
 	bool _needsFlip;
 	uint32 _drawNum;
 	Common::Rect _renderRect;
@@ -119,11 +107,15 @@ private:
 	int _borderRight;
 	int _borderBottom;
 
-	static const bool _disableDirtyRects = true;
+	bool _disableDirtyRects;
+	bool _spriteBatch;
+	uint32 _batchNum;
 	float _ratioX;
 	float _ratioY;
 	uint32 _colorMod;
 	uint32 _clearColor;
+
+	bool _skipThisFrame;
 };
 
 } // end of namespace Wintermute
diff --git a/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp b/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
index bee876bb65..e3e4884fbb 100644
--- a/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
+++ b/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
@@ -47,9 +47,9 @@ namespace Wintermute {
 //////////////////////////////////////////////////////////////////////////
 BaseSurfaceOSystem::BaseSurfaceOSystem(BaseGame *inGame) : BaseSurface(inGame) {
 	_surface = new Graphics::Surface();
-	_alphaMask = NULL;
+	_alphaMask = nullptr;
 	_hasAlpha = true;
-	_lockPixels = NULL;
+	_lockPixels = nullptr;
 	_lockPitch = 0;
 	_loaded = false;
 }
@@ -59,11 +59,11 @@ BaseSurfaceOSystem::~BaseSurfaceOSystem() {
 	if (_surface) {
 		_surface->free();
 		delete _surface;
-		_surface = NULL;
+		_surface = nullptr;
 	}
 
 	delete[] _alphaMask;
-	_alphaMask = NULL;
+	_alphaMask = nullptr;
 
 	_gameRef->addMem(-_width * _height * 4);
 	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
@@ -140,23 +140,32 @@ bool BaseSurfaceOSystem::finishLoad() {
 	// Well, actually, we don't convert via 24-bit as the color-key application overwrites the Alpha-channel anyhow.
 	_surface->free();
 	delete _surface;
+
+	bool needsColorKey = false;
+	bool replaceAlpha = true;
 	if (_filename.hasSuffix(".bmp") && image->getSurface()->format.bytesPerPixel == 4) {
 		_surface = image->getSurface()->convertTo(g_system->getScreenFormat(), image->getPalette());
-		TransparentSurface trans(*_surface);
-		trans.applyColorKey(_ckRed, _ckGreen, _ckBlue);
+		needsColorKey = true;
+		replaceAlpha = false;
 	} else if (image->getSurface()->format.bytesPerPixel == 1 && image->getPalette()) {
 		_surface = image->getSurface()->convertTo(g_system->getScreenFormat(), image->getPalette());
-		TransparentSurface trans(*_surface);
-		trans.applyColorKey(_ckRed, _ckGreen, _ckBlue, true);
+		needsColorKey = true;
 	} else if (image->getSurface()->format.bytesPerPixel >= 3 && image->getSurface()->format != g_system->getScreenFormat()) {
 		_surface = image->getSurface()->convertTo(g_system->getScreenFormat());
 		if (image->getSurface()->format.bytesPerPixel == 3) {
-			TransparentSurface trans(*_surface);
-			trans.applyColorKey(_ckRed, _ckGreen, _ckBlue, true);
+			needsColorKey = true;
 		}
 	} else {
 		_surface = new Graphics::Surface();
 		_surface->copyFrom(*image->getSurface());
+		if (_surface->format.aBits() == 0) {
+			needsColorKey = true;
+		}
+	}
+	
+	if (needsColorKey) {
+		TransparentSurface trans(*_surface);
+		trans.applyColorKey(_ckRed, _ckGreen, _ckBlue, replaceAlpha);
 	}
 
 	_hasAlpha = hasTransparency(_surface);
@@ -177,7 +186,7 @@ void BaseSurfaceOSystem::genAlphaMask(Graphics::Surface *surface) {
 	return;
 	// TODO: Reimplement this
 	delete[] _alphaMask;
-	_alphaMask = NULL;
+	_alphaMask = nullptr;
 	if (!surface) {
 		return;
 	}
@@ -214,7 +223,7 @@ void BaseSurfaceOSystem::genAlphaMask(Graphics::Surface *surface) {
 
 	if (!hasTransparency) {
 		delete[] _alphaMask;
-		_alphaMask = NULL;
+		_alphaMask = nullptr;
 	}
 }
 
@@ -293,7 +302,7 @@ bool BaseSurfaceOSystem::isTransparentAtLite(int x, int y) {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurfaceOSystem::startPixelOp() {
-	//SDL_LockTexture(_texture, NULL, &_lockPixels, &_lockPitch);
+	//SDL_LockTexture(_texture, nullptr, &_lockPixels, &_lockPitch);
 	// Any pixel-op makes the caching useless:
 	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
 	renderer->invalidateTicketsFromSurface(this);
@@ -414,6 +423,12 @@ bool BaseSurfaceOSystem::drawSprite(int x, int y, Rect32 *rect, float zoomX, flo
 	return STATUS_OK;
 }
 
+bool BaseSurfaceOSystem::repeatLastDisplayOp(int offsetX, int offsetY, int numTimesX, int numTimesY) {
+	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
+	renderer->repeatLastDraw(offsetX, offsetY, numTimesX, numTimesY);
+	return STATUS_OK;
+}
+
 bool BaseSurfaceOSystem::putSurface(const Graphics::Surface &surface, bool hasAlpha) {
 	_loaded = true;
 	_surface->free();
diff --git a/engines/wintermute/base/gfx/osystem/base_surface_osystem.h b/engines/wintermute/base/gfx/osystem/base_surface_osystem.h
index 43422ef4e7..9091ec65b1 100644
--- a/engines/wintermute/base/gfx/osystem/base_surface_osystem.h
+++ b/engines/wintermute/base/gfx/osystem/base_surface_osystem.h
@@ -41,27 +41,28 @@ public:
 	BaseSurfaceOSystem(BaseGame *inGame);
 	~BaseSurfaceOSystem();
 
-	bool create(const Common::String &filename, bool defaultCK, byte ckRed, byte ckGreen, byte ckBlue, int lifeTime = -1, bool keepLoaded = false);
-	bool create(int width, int height);
+	bool create(const Common::String &filename, bool defaultCK, byte ckRed, byte ckGreen, byte ckBlue, int lifeTime = -1, bool keepLoaded = false) override;
+	bool create(int width, int height) override;
 
-	bool isTransparentAt(int x, int y);
-	bool isTransparentAtLite(int x, int y);
+	bool isTransparentAt(int x, int y) override;
+	bool isTransparentAtLite(int x, int y) override;
 
-	bool startPixelOp();
-	bool endPixelOp();
+	bool startPixelOp() override;
+	bool endPixelOp() override;
 
 
-	bool displayTransZoom(int x, int y, Rect32 rect, float zoomX, float zoomY, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false);
-	bool displayTrans(int x, int y, Rect32 rect, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false);
-	bool displayTransOffset(int x, int y, Rect32 rect, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false, int offsetX = 0, int offsetY = 0);
-	bool display(int x, int y, Rect32 rect, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false);
-	bool displayZoom(int x, int y, Rect32 rect, float zoomX, float zoomY, uint32 alpha = 0xFFFFFFFF, bool transparent = false, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false);
-	bool displayTransform(int x, int y, int hotX, int hotY, Rect32 Rect, float zoomX, float zoomY, uint32 alpha, float rotate, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false);
-	virtual bool putSurface(const Graphics::Surface &surface, bool hasAlpha = false);
+	bool displayTransZoom(int x, int y, Rect32 rect, float zoomX, float zoomY, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) override;
+	bool displayTrans(int x, int y, Rect32 rect, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) override;
+	bool displayTransOffset(int x, int y, Rect32 rect, uint32 alpha = 0xFFFFFFFF, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false, int offsetX = 0, int offsetY = 0) override;
+	bool display(int x, int y, Rect32 rect, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) override;
+	bool displayZoom(int x, int y, Rect32 rect, float zoomX, float zoomY, uint32 alpha = 0xFFFFFFFF, bool transparent = false, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) override;
+	bool displayTransform(int x, int y, int hotX, int hotY, Rect32 Rect, float zoomX, float zoomY, uint32 alpha, float rotate, TSpriteBlendMode blendMode = BLEND_NORMAL, bool mirrorX = false, bool mirrorY = false) override;
+	bool repeatLastDisplayOp(int offsetX, int offsetY, int numTimesX, int numTimesY) override;
+	virtual bool putSurface(const Graphics::Surface &surface, bool hasAlpha = false) override;
 	/*  static unsigned DLL_CALLCONV ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle);
 	    static int DLL_CALLCONV SeekProc(fi_handle handle, long offset, int origin);
 	    static long DLL_CALLCONV TellProc(fi_handle handle);*/
-	virtual int getWidth() {
+	virtual int getWidth() override {
 		if (!_loaded) {
 			finishLoad();
 		}
@@ -70,7 +71,7 @@ public:
 		}
 		return _width;
 	}
-	virtual int getHeight() {
+	virtual int getHeight() override {
 		if (!_loaded) {
 			finishLoad();
 		}
diff --git a/engines/wintermute/base/gfx/osystem/render_ticket.cpp b/engines/wintermute/base/gfx/osystem/render_ticket.cpp
new file mode 100644
index 0000000000..d253ddca4b
--- /dev/null
+++ b/engines/wintermute/base/gfx/osystem/render_ticket.cpp
@@ -0,0 +1,115 @@
+/* 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.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "engines/wintermute/graphics/transparent_surface.h"
+#include "engines/wintermute/base/gfx/osystem/render_ticket.h"
+
+namespace Wintermute {
+
+RenderTicket::RenderTicket(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRect, bool mirrorX, bool mirrorY, bool disableAlpha) : _owner(owner),
+_srcRect(*srcRect), _dstRect(*dstRect), _drawNum(0), _isValid(true), _wantsDraw(true), _hasAlpha(!disableAlpha) {
+	_colorMod = 0;
+	_batchNum = 0;
+	_mirror = TransparentSurface::FLIP_NONE;
+	if (mirrorX) {
+		_mirror |= TransparentSurface::FLIP_V;
+	}
+	if (mirrorY) {
+		_mirror |= TransparentSurface::FLIP_H;
+	}
+	if (surf) {
+		_surface = new Graphics::Surface();
+		_surface->create((uint16)srcRect->width(), (uint16)srcRect->height(), surf->format);
+		assert(_surface->format.bytesPerPixel == 4);
+		// Get a clipped copy of the surface
+		for (int i = 0; i < _surface->h; i++) {
+			memcpy(_surface->getBasePtr(0, i), surf->getBasePtr(srcRect->left, srcRect->top + i), srcRect->width() * _surface->format.bytesPerPixel);
+		}
+		// Then scale it if necessary
+		if (dstRect->width() != srcRect->width() || dstRect->height() != srcRect->height()) {
+			TransparentSurface src(*_surface, false);
+			Graphics::Surface *temp = src.scale(dstRect->width(), dstRect->height());
+			_surface->free();
+			delete _surface;
+			_surface = temp;
+		}
+	} else {
+		_surface = nullptr;
+	}
+}
+
+RenderTicket::~RenderTicket() {
+	if (_surface) {
+		_surface->free();
+		delete _surface;
+	}
+}
+
+bool RenderTicket::operator==(RenderTicket &t) {
+	if ((t._owner != _owner) ||
+		(t._batchNum != t._batchNum) ||
+		(t._hasAlpha != _hasAlpha) ||
+		(t._mirror != _mirror) ||
+		(t._colorMod != _colorMod) ||
+		(t._dstRect != _dstRect) ||
+		(t._srcRect != _srcRect)) {
+		return false;
+	}
+	return true;
+}
+
+// Replacement for SDL2's SDL_RenderCopy
+void RenderTicket::drawToSurface(Graphics::Surface *_targetSurface) {
+	TransparentSurface src(*getSurface(), false);
+
+	Common::Rect clipRect;
+	clipRect.setWidth(getSurface()->w);
+	clipRect.setHeight(getSurface()->h);
+
+	src._enableAlphaBlit = _hasAlpha;
+	src.blit(*_targetSurface, _dstRect.left, _dstRect.top, _mirror, &clipRect, _colorMod, clipRect.width(), clipRect.height());
+}
+
+void RenderTicket::drawToSurface(Graphics::Surface *_targetSurface, Common::Rect *dstRect, Common::Rect *clipRect) {
+	TransparentSurface src(*getSurface(), false);
+	bool doDelete = false;
+	if (!clipRect) {
+		doDelete = true;
+		clipRect = new Common::Rect();
+		clipRect->setWidth(getSurface()->w);
+		clipRect->setHeight(getSurface()->h);
+	}
+
+	src._enableAlphaBlit = _hasAlpha;
+	src.blit(*_targetSurface, dstRect->left, dstRect->top, _mirror, clipRect, _colorMod, clipRect->width(), clipRect->height());
+	if (doDelete) {
+		delete clipRect;
+	}
+}
+
+} // end of namespace Wintermute
diff --git a/engines/wintermute/base/gfx/osystem/render_ticket.h b/engines/wintermute/base/gfx/osystem/render_ticket.h
new file mode 100644
index 0000000000..968b42b5e1
--- /dev/null
+++ b/engines/wintermute/base/gfx/osystem/render_ticket.h
@@ -0,0 +1,69 @@
+/* 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.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#ifndef WINTERMUTE_RENDER_TICKET_H
+#define WINTERMUTE_RENDER_TICKET_H
+
+#include "graphics/surface.h"
+#include "common/rect.h"
+
+namespace Wintermute {
+
+class BaseSurfaceOSystem;
+class RenderTicket {
+public:
+	RenderTicket(BaseSurfaceOSystem *owner, const Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRest, bool mirrorX = false, bool mirrorY = false, bool disableAlpha = false);
+	RenderTicket() : _isValid(true), _wantsDraw(false), _drawNum(0) {}
+	~RenderTicket();
+	const Graphics::Surface *getSurface() { return _surface; }
+	// Non-dirty-rects:
+	void drawToSurface(Graphics::Surface *_targetSurface);
+	// Dirty-rects:
+	void drawToSurface(Graphics::Surface *_targetSurface, Common::Rect *dstRect, Common::Rect *clipRect);
+
+	Common::Rect _dstRect;
+	uint32 _batchNum;
+
+	bool _isValid;
+	bool _wantsDraw;
+	uint32 _drawNum;
+	uint32 _colorMod;
+
+	BaseSurfaceOSystem *_owner;
+	bool operator==(RenderTicket &a);
+	const Common::Rect *getSrcRect() { return &_srcRect; }
+private:
+	Graphics::Surface *_surface;
+	Common::Rect _srcRect;
+	bool _hasAlpha;
+	uint32 _mirror;
+};
+
+} // end of namespace Wintermute
+
+#endif