Split from Graphics SDL related code into SDLGraphics.

16 files changed, 1014 insertions, 804 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6f2638ebb..a46683928 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -688,6 +688,8 @@ SET(SRCS
     rotationalparticle.h
     safeopenglgraphics.cpp
     safeopenglgraphics.h
+    sdlgraphics.cpp
+    sdlgraphics.h
     shopitem.cpp
     shopitem.h
     simpleanimation.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
index 27069e927..a3b551313 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -689,6 +689,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \
 	      rotationalparticle.h \
 	      safeopenglgraphics.cpp\
 	      safeopenglgraphics.h \
+	      sdlgraphics.cpp \
+	      sdlgraphics.h \
 	      shopitem.cpp \
 	      shopitem.h \
 	      simpleanimation.cpp \
diff --git a/src/compoundsprite.cpp b/src/compoundsprite.cpp
index 748bf4d42..0d649e48e 100644
--- a/src/compoundsprite.cpp
+++ b/src/compoundsprite.cpp
@@ -21,16 +21,16 @@
 
 #include "compoundsprite.h"
 
+#include "client.h"
 #include "configuration.h"
 #include "game.h"
-#include "graphics.h"
 
 #ifdef USE_OPENGL
 #include "main.h"
 #endif
 
-#include "client.h"
 #include "map.h"
+#include "sdlgraphics.h"
 
 #include "resources/image.h"
 #include "resources/imagehelper.h"
@@ -330,8 +330,8 @@ void CompoundSprite::redraw() const
     if (!surface)
         return;
 
-    Graphics *graphics = new Graphics();
-    graphics->setBlitMode(Graphics::BLIT_GFX);
+    SDLGraphics *graphics = new SDLGraphics();
+    graphics->setBlitMode(SDLGraphics::BLIT_GFX);
     graphics->setTarget(surface);
     graphics->_beginDraw();
 
diff --git a/src/graphics.cpp b/src/graphics.cpp
index a14d630bf..f32d35f3e 100644
--- a/src/graphics.cpp
+++ b/src/graphics.cpp
@@ -50,12 +50,6 @@
 #endif
 #endif
 
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-static unsigned int *cR = nullptr;
-static unsigned int *cG = nullptr;
-static unsigned int *cB = nullptr;
-#endif
-
 int MSDL_gfxBlitRGBA(SDL_Surface *src, SDL_Rect *srcrect,
                      SDL_Surface *dst, SDL_Rect *dstrect)
 {
@@ -69,7 +63,6 @@ Graphics::Graphics() :
     mBpp(0),
     mFullscreen(false),
     mHWAccel(false),
-    mBlitMode(BLIT_NORMAL),
     mRedraw(false),
     mDoubleBuffer(false),
     mRect(),
@@ -77,8 +70,6 @@ Graphics::Graphics() :
     mOpenGL(0),
     mEnableResize(false),
     mNoFrame(false),
-    mOldPixel(0),
-    mOldAlpha(0),
     mName("Software"),
     mStartFreeMem(0),
     mSync(false),
@@ -375,185 +366,6 @@ bool Graphics::drawImage(const Image *image, int x, int y)
     }
 }
 
-bool Graphics::drawRescaledImage(const Image *const image, int srcX, int srcY,
-                                 int dstX, int dstY,
-                                 const int width, const int height,
-                                 const int desiredWidth,
-                                 const int desiredHeight,
-                                 const bool useColor A_UNUSED)
-{
-    FUNC_BLOCK("Graphics::drawRescaledImage", 1)
-    // Check that preconditions for blitting are met.
-    if (!mTarget || !image)
-        return false;
-    if (!image->mSDLSurface)
-        return false;
-
-    Image *const tmpImage = image->SDLgetScaledImage(
-        desiredWidth, desiredHeight);
-
-    if (!tmpImage)
-        return false;
-    if (!tmpImage->mSDLSurface)
-        return false;
-
-    dstX += mClipStack.top().xOffset;
-    dstY += mClipStack.top().yOffset;
-
-    srcX += image->mBounds.x;
-    srcY += image->mBounds.y;
-
-    SDL_Rect dstRect;
-    SDL_Rect srcRect;
-    dstRect.x = static_cast<int16_t>(dstX);
-    dstRect.y = static_cast<int16_t>(dstY);
-    srcRect.x = static_cast<int16_t>(srcX);
-    srcRect.y = static_cast<int16_t>(srcY);
-    srcRect.w = static_cast<uint16_t>(width);
-    srcRect.h = static_cast<uint16_t>(height);
-
-    const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface,
-        &srcRect, mTarget, &dstRect) < 0);
-
-    delete tmpImage;
-
-    return returnValue;
-}
-
-bool Graphics::drawImage2(const Image *const image, int srcX, int srcY,
-                          int dstX, int dstY, const int width,
-                          const int height, const bool useColor A_UNUSED)
-{
-    FUNC_BLOCK("Graphics::drawImage2", 1)
-    // Check that preconditions for blitting are met.
-    if (!mTarget || !image || !image->mSDLSurface)
-        return false;
-
-    dstX += mClipStack.top().xOffset;
-    dstY += mClipStack.top().yOffset;
-
-    srcX += image->mBounds.x;
-    srcY += image->mBounds.y;
-
-    SDL_Rect dstRect;
-    SDL_Rect srcRect;
-    dstRect.x = static_cast<int16_t>(dstX);
-    dstRect.y = static_cast<int16_t>(dstY);
-    srcRect.x = static_cast<int16_t>(srcX);
-    srcRect.y = static_cast<int16_t>(srcY);
-    srcRect.w = static_cast<uint16_t>(width);
-    srcRect.h = static_cast<uint16_t>(height);
-
-    if (mBlitMode == BLIT_NORMAL)
-    {
-        return !(SDL_BlitSurface(image->mSDLSurface, &srcRect,
-                                 mTarget, &dstRect) < 0);
-    }
-    else
-    {
-        return !(SDL_gfxBlitRGBA(image->mSDLSurface, &srcRect,
-                                 mTarget, &dstRect) < 0);
-    }
-}
-
-void Graphics::drawImagePattern(const Image *const image,
-                                const int x, const int y,
-                                const int w, const int h)
-{
-    FUNC_BLOCK("Graphics::drawImagePattern", 1)
-    // Check that preconditions for blitting are met.
-    if (!mTarget || !image)
-        return;
-    if (!image->mSDLSurface)
-        return;
-
-    const int iw = image->mBounds.w;
-    const int ih = image->mBounds.h;
-
-    if (iw == 0 || ih == 0)
-        return;
-
-    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
-    {
-        const int dh = (py + ih >= h) ? h - py : ih;
-        const int srcY = image->mBounds.y;
-        const int dstY = y + py + mClipStack.top().yOffset;
-
-        for (int px = 0; px < w; px += iw)  // X position on pattern plane
-        {
-            const int dw = (px + iw >= w) ? w - px : iw;
-            const int srcX = image->mBounds.x;
-            const int dstX = x + px + mClipStack.top().xOffset;
-
-            SDL_Rect dstRect;
-            SDL_Rect srcRect;
-            dstRect.x = static_cast<int16_t>(dstX);
-            dstRect.y = static_cast<int16_t>(dstY);
-            srcRect.x = static_cast<int16_t>(srcX);
-            srcRect.y = static_cast<int16_t>(srcY);
-            srcRect.w = static_cast<uint16_t>(dw);
-            srcRect.h = static_cast<uint16_t>(dh);
-
-            SDL_BlitSurface(image->mSDLSurface, &srcRect, mTarget, &dstRect);
-        }
-    }
-}
-
-void Graphics::drawRescaledImagePattern(const Image *const image,
-                                        const int x, const int y,
-                                        const int w, const int h,
-                                        const int scaledWidth,
-                                        const int scaledHeight)
-{
-    // Check that preconditions for blitting are met.
-    if (!mTarget || !image)
-        return;
-    if (!image->mSDLSurface)
-        return;
-
-    if (scaledHeight == 0 || scaledWidth == 0)
-        return;
-
-    Image *const tmpImage = image->SDLgetScaledImage(
-        scaledWidth, scaledHeight);
-    if (!tmpImage)
-        return;
-
-    const int iw = tmpImage->mBounds.w;
-    const int ih = tmpImage->mBounds.h;
-
-    if (iw == 0 || ih == 0)
-        return;
-
-    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
-    {
-        const int dh = (py + ih >= h) ? h - py : ih;
-        const int srcY = tmpImage->mBounds.y;
-        const int dstY = y + py + mClipStack.top().yOffset;
-
-        for (int px = 0; px < w; px += iw)  // X position on pattern plane
-        {
-            const int dw = (px + iw >= w) ? w - px : iw;
-            const int srcX = tmpImage->mBounds.x;
-            const int dstX = x + px + mClipStack.top().xOffset;
-
-            SDL_Rect dstRect;
-            SDL_Rect srcRect;
-            dstRect.x = static_cast<int16_t>(dstX);
-            dstRect.y = static_cast<int16_t>(dstY);
-            srcRect.x = static_cast<int16_t>(srcX);
-            srcRect.y = static_cast<int16_t>(srcY);
-            srcRect.w = static_cast<uint16_t>(dw);
-            srcRect.h = static_cast<uint16_t>(dh);
-
-            SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect,
-                            mTarget, &dstRect);
-        }
-    }
-
-    delete tmpImage;
-}
-
 void Graphics::drawImageRect(const int x, const int y,
                              const int w, const int h,
                              const Image *const topLeft,
@@ -614,6 +426,18 @@ void Graphics::drawImageRect(int x, int y, int w, int h,
             imgRect.grid[4]);
 }
 
+bool Graphics::drawNet(const int x1, const int y1, const int x2, const int y2,
+                       const int width, const int height)
+{
+    for (int y = y1; y < y2; y += height)
+        drawLine(x1, y, x2, y);
+
+    for (int x = x1; x < x2; x += width)
+        drawLine(x, y1, x, y2);
+
+    return true;
+}
+
 bool Graphics::calcImageRect(ImageVertexes *const vert,
                              const int x, const int y,
                              const int w, const int h,
@@ -673,540 +497,3 @@ bool Graphics::calcImageRect(ImageVertexes *const vert,
     BLOCK_END("Graphics::calcImageRect")
     return 0;
 }
-
-void Graphics::calcImagePattern(ImageVertexes* const vert,
-                                const Image *const image,
-                                const int x, const int y,
-                                const int w, const int h) const
-{
-    // Check that preconditions for blitting are met.
-    if (!vert || !mTarget || !image || !image->mSDLSurface)
-        return;
-
-    const int iw = image->mBounds.w;
-    const int ih = image->mBounds.h;
-
-    if (iw == 0 || ih == 0)
-        return;
-
-    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
-    {
-        const int dh = (py + ih >= h) ? h - py : ih;
-        const int srcY = image->mBounds.y;
-        const int dstY = y + py + mClipStack.top().yOffset;
-
-        for (int px = 0; px < w; px += iw)  // X position on pattern plane
-        {
-            const int dw = (px + iw >= w) ? w - px : iw;
-            const int srcX = image->mBounds.x;
-            const int dstX = x + px + mClipStack.top().xOffset;
-
-            DoubleRect *const r = new DoubleRect();
-            SDL_Rect &dstRect = r->dst;
-            SDL_Rect &srcRect = r->src;
-            dstRect.x = static_cast<int16_t>(dstX);
-            dstRect.y = static_cast<int16_t>(dstY);
-            srcRect.x = static_cast<int16_t>(srcX);
-            srcRect.y = static_cast<int16_t>(srcY);
-            srcRect.w = static_cast<uint16_t>(dw);
-            srcRect.h = static_cast<uint16_t>(dh);
-
-            if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect,
-                mTarget, &dstRect) == 1)
-            {
-                vert->sdl.push_back(r);
-            }
-            else
-            {
-                delete r;
-            }
-        }
-    }
-}
-
-void Graphics::calcImagePattern(ImageCollection* const vertCol,
-                                const Image *const image,
-                                const int x, const int y,
-                                const int w, const int h) const
-{
-    ImageVertexes *vert = nullptr;
-    if (vertCol->currentImage != image)
-    {
-        vert = new ImageVertexes();
-        vertCol->currentImage = image;
-        vertCol->currentVert = vert;
-        vert->image = image;
-        vertCol->draws.push_back(vert);
-    }
-    else
-    {
-        vert = vertCol->currentVert;
-    }
-
-    calcImagePattern(vert, image, x, y, w, h);
-}
-
-void Graphics::calcTile(ImageVertexes *const vert,
-                        const Image *const image,
-                        int x, int y) const
-{
-    vert->image = image;
-    calcTile(vert, x, y);
-}
-
-void Graphics::calcTile(ImageCollection *const vertCol,
-                        const Image *const image,
-                        int x, int y)
-{
-    if (vertCol->currentImage != image)
-    {
-        ImageVertexes *const vert = new ImageVertexes();
-        vertCol->currentImage = image;
-        vertCol->currentVert = vert;
-        vert->image = image;
-        vertCol->draws.push_back(vert);
-        calcTile(vert, x, y);
-    }
-    else
-    {
-        calcTile(vertCol->currentVert, x, y);
-    }
-}
-
-void Graphics::drawTile(const ImageCollection *const vertCol)
-{
-    const ImageVertexesVector &draws = vertCol->draws;
-    const ImageCollectionCIter it_end = draws.end();
-    for (ImageCollectionCIter it = draws.begin(); it != it_end; ++ it)
-    {
-        const ImageVertexes *const vert = *it;
-        const Image *const img = vert->image;
-        const DoubleRects *const rects = &vert->sdl;
-        DoubleRects::const_iterator it2 = rects->begin();
-        const DoubleRects::const_iterator it2_end = rects->end();
-        while (it2 != it2_end)
-        {
-            SDL_LowerBlit(img->mSDLSurface, &(*it2)->src,
-                mTarget, &(*it2)->dst);
-            ++ it2;
-        }
-    }
-}
-
-void Graphics::calcTile(ImageVertexes *const vert, int x, int y) const
-{
-    // Check that preconditions for blitting are met.
-    if (!vert || !vert->image || !vert->image->mSDLSurface)
-        return;
-
-    const Image *const image = vert->image;
-
-    x += mClipStack.top().xOffset;
-    y += mClipStack.top().yOffset;
-
-    DoubleRect *rect = new DoubleRect();
-
-    rect->dst.x = static_cast<int16_t>(x);
-    rect->dst.y = static_cast<int16_t>(y);
-    rect->src.x = static_cast<int16_t>(image->mBounds.x);
-    rect->src.y = static_cast<int16_t>(image->mBounds.y);
-    rect->src.w = static_cast<uint16_t>(image->mBounds.w);
-    rect->src.h = static_cast<uint16_t>(image->mBounds.h);
-    if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src,
-        mTarget, &rect->dst) == 1)
-    {
-        vert->sdl.push_back(rect);
-    }
-    else
-    {
-        delete rect;
-    }
-}
-
-void Graphics::drawTile(const ImageVertexes *const vert)
-{
-    // vert and img must be != 0
-    const Image *const img = vert->image;
-    const DoubleRects *const rects = &vert->sdl;
-    DoubleRects::const_iterator it = rects->begin();
-    const DoubleRects::const_iterator it_end = rects->end();
-    while (it != it_end)
-    {
-        SDL_LowerBlit(img->mSDLSurface, &(*it)->src, mTarget, &(*it)->dst);
-        ++ it;
-    }
-}
-
-void Graphics::updateScreen()
-{
-    BLOCK_START("Graphics::updateScreen")
-    if (mDoubleBuffer)
-    {
-        SDL_Flip(mTarget);
-    }
-    else
-    {
-        SDL_UpdateRects(mTarget, 1, &mRect);
-//        SDL_UpdateRect(mTarget, 0, 0, 0, 0);
-    }
-    BLOCK_END("Graphics::updateScreen")
-}
-
-SDL_Surface *Graphics::getScreenshot()
-{
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    const int rmask = 0xff000000;
-    const int gmask = 0x00ff0000;
-    const int bmask = 0x0000ff00;
-#else
-    const int rmask = 0x000000ff;
-    const int gmask = 0x0000ff00;
-    const int bmask = 0x00ff0000;
-#endif
-    const int amask = 0x00000000;
-
-    SDL_Surface *const screenshot = SDL_CreateRGBSurface(SDL_SWSURFACE,
-        mTarget->w, mTarget->h, 24, rmask, gmask, bmask, amask);
-
-    if (screenshot)
-        SDL_BlitSurface(mTarget, nullptr, screenshot, nullptr);
-
-    return screenshot;
-}
-
-bool Graphics::drawNet(const int x1, const int y1, const int x2, const int y2,
-                       const int width, const int height)
-{
-    for (int y = y1; y < y2; y += height)
-        drawLine(x1, y, x2, y);
-
-    for (int x = x1; x < x2; x += width)
-        drawLine(x, y1, x, y2);
-
-    return true;
-}
-
-bool Graphics::calcWindow(ImageCollection *const vertCol,
-                          const int x, const int y, const int w, const int h,
-                          const ImageRect &imgRect)
-{
-    ImageVertexes *vert = nullptr;
-    Image *const image = imgRect.grid[4];
-    if (vertCol->currentImage != image)
-    {
-        vert = new ImageVertexes();
-        vertCol->currentImage = image;
-        vertCol->currentVert = vert;
-        vert->image = image;
-        vertCol->draws.push_back(vert);
-//        calcTile(vert, x, y);
-    }
-    else
-    {
-        vert = vertCol->currentVert;
-    }
-
-    return calcImageRect(vert, x, y, w, h,
-        imgRect.grid[0], imgRect.grid[2], imgRect.grid[6], imgRect.grid[8],
-        imgRect.grid[1], imgRect.grid[5], imgRect.grid[7], imgRect.grid[3],
-        imgRect.grid[4]);
-}
-
-int Graphics::SDL_FakeUpperBlit(const SDL_Surface *const src,
-                                SDL_Rect *const srcrect,
-                                const SDL_Surface *const dst,
-                                SDL_Rect *dstrect) const
-{
-    SDL_Rect fulldst;
-    int srcx, srcy, w, h;
-
-    /* Make sure the surfaces aren't locked */
-    if (!src || !dst)
-        return -1;
-
-    if (src->locked || dst->locked)
-        return -1;
-
-    /* If the destination rectangle is nullptr, use the entire dest surface */
-    if (!dstrect)
-    {
-        fulldst.x = 0;
-        fulldst.y = 0;
-        dstrect = &fulldst;
-    }
-
-    /* clip the source rectangle to the source surface */
-    if (srcrect)
-    {
-        srcx = srcrect->x;
-        w = srcrect->w;
-        if (srcx < 0)
-        {
-            w += srcx;
-            dstrect->x -= static_cast<int16_t>(srcx);
-            srcx = 0;
-        }
-        int maxw = src->w - srcx;
-        if (maxw < w)
-            w = maxw;
-
-        srcy = srcrect->y;
-        h = srcrect->h;
-        if (srcy < 0)
-        {
-            h += srcy;
-            dstrect->y -= static_cast<int16_t>(srcy);
-            srcy = 0;
-        }
-        int maxh = src->h - srcy;
-        if (maxh < h)
-            h = maxh;
-    }
-    else
-    {
-        srcx = 0;
-        srcy = 0;
-        w = src->w;
-        h = src->h;
-    }
-
-    /* clip the destination rectangle against the clip rectangle */
-    {
-        const SDL_Rect *const clip = &dst->clip_rect;
-        int dx = clip->x - dstrect->x;
-        if (dx > 0)
-        {
-            w -= dx;
-            dstrect->x += static_cast<int16_t>(dx);
-            srcx += dx;
-        }
-        dx = dstrect->x + w - clip->x - clip->w;
-        if (dx > 0)
-            w -= dx;
-
-        int dy = clip->y - dstrect->y;
-        if (dy > 0)
-        {
-            h -= dy;
-            dstrect->y += static_cast<int16_t>(dy);
-            srcy += dy;
-        }
-        dy = dstrect->y + h - clip->y - clip->h;
-        if (dy > 0)
-            h -= dy;
-    }
-
-    if (w > 0 && h > 0)
-    {
-        if (srcrect)
-        {
-            srcrect->x = static_cast<int16_t>(srcx);
-            srcrect->y = static_cast<int16_t>(srcy);
-            srcrect->w = static_cast<int16_t>(w);
-            srcrect->h = static_cast<int16_t>(h);
-        }
-        dstrect->w = static_cast<int16_t>(w);
-        dstrect->h = static_cast<int16_t>(h);
-
-        return 1;
-//        return SDL_LowerBlit(src, &sr, dst, dstrect);
-    }
-    dstrect->w = dstrect->h = 0;
-    return 0;
-}
-
-void Graphics::fillRectangle(const gcn::Rectangle& rectangle)
-{
-    FUNC_BLOCK("Graphics::fillRectangle", 1)
-    if (mClipStack.empty())
-        return;
-
-    const gcn::ClipRectangle& top = mClipStack.top();
-
-    gcn::Rectangle area = rectangle;
-    area.x += top.xOffset;
-    area.y += top.yOffset;
-
-    if (!area.isIntersecting(top))
-        return;
-
-    if (mAlpha)
-    {
-        const int x1 = area.x > top.x ? area.x : top.x;
-        const int y1 = area.y > top.y ? area.y : top.y;
-        const int x2 = area.x + area.width < top.x + top.width ?
-            area.x + area.width : top.x + top.width;
-        const int y2 = area.y + area.height < top.y + top.height ?
-            area.y + area.height : top.y + top.height;
-        int x, y;
-
-        SDL_LockSurface(mTarget);
-
-        const int bpp = mTarget->format->BytesPerPixel;
-        const uint32_t pixel = SDL_MapRGB(mTarget->format,
-            static_cast<uint8_t>(mColor.r), static_cast<uint8_t>(mColor.g),
-            static_cast<uint8_t>(mColor.b));
-
-        switch (bpp)
-        {
-            case 1:
-                for (y = y1; y < y2; y++)
-                {
-                    uint8_t *const p = static_cast<uint8_t *>(mTarget->pixels)
-                        + y * mTarget->pitch;
-                    for (x = x1; x < x2; x++)
-                        *(p + x) = static_cast<uint8_t>(pixel);
-                }
-                break;
-            case 2:
-                for (y = y1; y < y2; y++)
-                {
-                    uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
-                        + y * mTarget->pitch;
-                    for (x = x1; x < x2; x++)
-                    {
-                        uint8_t *const p = p0 + x * 2;
-                        *reinterpret_cast<uint16_t *>(p) = gcn::SDLAlpha16(
-                            static_cast<uint16_t>(pixel),
-                            *reinterpret_cast<uint16_t *>(p),
-                            static_cast<uint8_t>(mColor.a), mTarget->format);
-                    }
-                }
-                break;
-            case 3:
-            {
-                const int ca = 255 - mColor.a;
-                const int cr = mColor.r * mColor.a;
-                const int cg = mColor.g * mColor.a;
-                const int cb = mColor.b * mColor.a;
-
-                for (y = y1; y < y2; y++)
-                {
-                    uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
-                        + y * mTarget->pitch;
-                    for (x = x1; x < x2; x++)
-                    {
-                        uint8_t *const p = p0 + x * 3;
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-                        p[2] = static_cast<uint8_t>((p[2] * ca + cb) >> 8);
-                        p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
-                        p[0] = static_cast<uint8_t>((p[0] * ca + cr) >> 8);
-#else
-                        p[0] = static_cast<uint8_t>((p[0] * ca + cb) >> 8);
-                        p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
-                        p[2] = static_cast<uint8_t>((p[2] * ca + cr) >> 8);
-#endif
-                    }
-                }
-                break;
-            }
-            case 4:
-            {
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-                const unsigned pb = (pixel & 0xff) * mColor.a;
-                const unsigned pg = (pixel & 0xff00) * mColor.a;
-                const unsigned pr = (pixel & 0xff0000) * mColor.a;
-                const unsigned a1 = (255 - mColor.a);
-
-                for (y = y1; y < y2; y++)
-                {
-                    uint8_t *p0 = static_cast<uint8_t *>(mTarget->pixels)
-                        + y * mTarget->pitch;
-                    for (x = x1; x < x2; x++)
-                    {
-                        uint8_t *p = p0 + x * 4;
-                        uint32_t dst = *reinterpret_cast<uint32_t *>(p);
-                        const unsigned int b = (pb + (dst & 0xff) * a1) >> 8;
-                        const unsigned int g = (pg + (dst & 0xff00) * a1) >> 8;
-                        const unsigned int r = (pr
-                            + (dst & 0xff0000) * a1) >> 8;
-
-                        *reinterpret_cast<uint32_t *>(p) = ((b & 0xff)
-                            | (g & 0xff00) | (r & 0xff0000));
-                    }
-                }
-#else
-                if (!cR)
-                {
-                    cR = new unsigned int[0x100];
-                    cG = new unsigned int[0x100];
-                    cB = new unsigned int[0x100];
-                    mOldPixel = 0;
-                    mOldAlpha = mColor.a;
-                }
-
-                const SDL_PixelFormat * const format = mTarget->format;
-                const unsigned rMask = format->Rmask;
-                const unsigned gMask = format->Gmask;
-                const unsigned bMask = format->Bmask;
-//                const unsigned aMask = format->Amask;
-                unsigned rShift = rMask / 0xff;
-                unsigned gShift = gMask / 0xff;
-                unsigned bShift = bMask / 0xff;
-                if (!rShift)
-                    rShift = 1;
-                if (!gShift)
-                    gShift = 1;
-                if (!bShift)
-                    bShift = 1;
-                if (pixel != mOldPixel || mColor.a != mOldAlpha)
-                {
-                    const unsigned pb = (pixel & bMask) * mColor.a;
-                    const unsigned pg = (pixel & gMask) * mColor.a;
-                    const unsigned pr = (pixel & rMask) * mColor.a;
-                    const unsigned a0 = (255 - mColor.a);
-
-                    const unsigned int a1 = a0 * bShift;
-                    const unsigned int a2 = a0 * gShift;
-                    const unsigned int a3 = a0 * rShift;
-
-                    for (int f = 0; f <= 0xff; f ++)
-                    {
-                        cB[f] = ((pb + f * a1) >> 8) & bMask;
-                        cG[f] = ((pg + f * a2) >> 8) & gMask;
-                        cR[f] = ((pr + f * a3) >> 8) & rMask;
-                    }
-
-                    mOldPixel = pixel;
-                    mOldAlpha = mColor.a;
-                }
-
-                for (y = y1; y < y2; y++)
-                {
-                    uint32_t *const p0 = reinterpret_cast<uint32_t*>(
-                        static_cast<uint8_t*>(mTarget->pixels)
-                        + y * mTarget->pitch);
-                    for (x = x1; x < x2; x++)
-                    {
-                        uint32_t *const p = p0 + x;
-                        const uint32_t dst = *p;
-                        *p = cB[dst & bMask / bShift]
-                            | cG[(dst & gMask) / gShift]
-                            | cR[(dst & rMask) / rShift];
-                    }
-                }
-#endif
-                break;
-            }
-            default:
-                break;
-        }
-
-        SDL_UnlockSurface(mTarget);
-    }
-    else
-    {
-        SDL_Rect rect;
-        rect.x = static_cast<int16_t>(area.x);
-        rect.y = static_cast<int16_t>(area.y);
-        rect.w = static_cast<uint16_t>(area.width);
-        rect.h = static_cast<uint16_t>(area.height);
-
-        const uint32_t color = SDL_MapRGBA(mTarget->format,
-            static_cast<int8_t>(mColor.r),
-            static_cast<int8_t>(mColor.g),
-            static_cast<int8_t>(mColor.b),
-            static_cast<int8_t>(mColor.a));
-        SDL_FillRect(mTarget, &rect, color);
-    }
-}
diff --git a/src/graphics.h b/src/graphics.h
index f8a124a89..60313fdaf 100644
--- a/src/graphics.h
+++ b/src/graphics.h
@@ -90,12 +90,6 @@ class ImageRect final
 class Graphics : public gcn::SDLGraphics
 {
     public:
-        enum BlitMode
-        {
-            BLIT_NORMAL = 0,
-            BLIT_GFX
-        };
-
         /**
          * Constructor.
          */
@@ -145,33 +139,16 @@ class Graphics : public gcn::SDLGraphics
         /**
          * Draws a resclaled version of the image
          */
-        bool drawRescaledImage(const Image *const image,
-                               const int srcX, const int srcY,
-                               const int dstX, const int dstY,
-                               const int width, const int height,
-                               const int desiredWidth, const int desiredHeight)
-        {
-            return drawRescaledImage(image, srcX, srcY,
-                                     dstX, dstY,
-                                     width, height,
-                                     desiredWidth, desiredHeight,
-                                     false);
-        }
-
-        /**
-         * Draws a resclaled version of the image
-         */
         virtual bool drawRescaledImage(const Image *const image, int srcX,
                                        int srcY, int dstX, int dstY,
                                        const int width, const int height,
                                        const int desiredWidth,
                                        const int desiredHeight,
-                                       const bool useColor = false);
-
+                                       const bool useColor = false) = 0;
 
         virtual void drawImagePattern(const Image *const image,
                                       const int x, const int y,
-                                      const int w, const int h);
+                                      const int w, const int h) = 0;
 
         /**
          * Draw a pattern based on a rescaled version of the given image...
@@ -180,7 +157,7 @@ class Graphics : public gcn::SDLGraphics
                                               const int x, const int y,
                                               const int w, const int h,
                                               const int scaledWidth,
-                                              const int scaledHeight);
+                                              const int scaledHeight) = 0;
 
         /**
          * Draws a rectangle using images. 4 corner images, 4 side images and 1
@@ -204,46 +181,50 @@ class Graphics : public gcn::SDLGraphics
         void drawImageRect(int x, int y, int w, int h,
                            const ImageRect &imgRect);
 
-        virtual bool calcImageRect(ImageVertexes *const vert,
-                                   const int x, const int y,
-                                   const int w, const int h,
-                                   const Image *const topLeft,
-                                   const Image *const topRight,
-                                   const Image *const bottomLeft,
-                                   const Image *const bottomRight,
-                                   const Image *const top,
-                                   const Image *const right,
-                                   const Image *const bottom,
-                                   const Image *const left,
-                                   const Image *const center);
+        bool calcImageRect(ImageVertexes *const vert,
+                           const int x, const int y,
+                           const int w, const int h,
+                           const Image *const topLeft,
+                           const Image *const topRight,
+                           const Image *const bottomLeft,
+                           const Image *const bottomRight,
+                           const Image *const top,
+                           const Image *const right,
+                           const Image *const bottom,
+                           const Image *const left,
+                           const Image *const center);
 
         virtual void calcImagePattern(ImageVertexes *const vert,
                                       const Image *const image,
                                       const int x, const int y,
-                                      const int w, const int h) const;
+                                      const int w, const int h) const = 0;
 
         virtual void calcImagePattern(ImageCollection *const vert,
                                       const Image *const image,
                                       const int x, const int y,
-                                      const int w, const int h) const;
+                                      const int w, const int h) const = 0;
 
         virtual void calcTile(ImageVertexes *const vert,
-                              const Image *const image, int x, int y) const;
+                              const Image *const image,
+                              int x, int y) const = 0;
 
-        virtual void calcTile(ImageVertexes *const vert, int x, int y) const;
+        virtual void calcTileSDL(ImageVertexes *const vert A_UNUSED,
+                                 int x A_UNUSED, int y A_UNUSED) const
+        {
+        }
 
-        virtual void drawTile(const ImageVertexes *const vert);
+        virtual void drawTile(const ImageVertexes *const vert) = 0;
 
-        virtual void drawTile(const ImageCollection *const vertCol);
+        virtual void drawTile(const ImageCollection *const vertCol) = 0;
 
         virtual void calcTile(ImageCollection *const vertCol,
                               const Image *const image,
-                              int x, int y);
+                              int x, int y) = 0;
 
         virtual bool calcWindow(ImageCollection *const vertCol,
                                 const int x, const int y,
                                 const int w, const int h,
-                                const ImageRect &imgRect);
+                                const ImageRect &imgRect) = 0;
 
         /**
          * Draws a rectangle using images. 4 corner images, 4 side images and 1
@@ -253,19 +234,14 @@ class Graphics : public gcn::SDLGraphics
                                   const ImageRect &imgRect)
         { drawImageRect(area.x, area.y, area.width, area.height, imgRect); }
 
-        void setBlitMode(const BlitMode mode)
-        { mBlitMode = mode; }
-
-        BlitMode getBlitMode() const A_WARN_UNUSED
-        { return mBlitMode; }
-
-        void fillRectangle(const gcn::Rectangle& rectangle) override;
+        virtual void fillRectangle(const gcn::Rectangle& rectangle)
+                                   override = 0;
 
         /**
          * Updates the screen. This is done by either copying the buffer to the
          * screen or swapping pages.
          */
-        virtual void updateScreen();
+        virtual void updateScreen() = 0;
 
         /**
          * Returns the width of the screen.
@@ -280,7 +256,7 @@ class Graphics : public gcn::SDLGraphics
         /**
          * Takes a screenshot and returns it as SDL surface.
          */
-        virtual SDL_Surface *getScreenshot() A_WARN_UNUSED;
+        virtual SDL_Surface *getScreenshot() A_WARN_UNUSED = 0;
 
         virtual void prepareScreenshot()
         { }
@@ -375,7 +351,7 @@ class Graphics : public gcn::SDLGraphics
                                 int srcX, int srcY,
                                 int dstX, int dstY,
                                 const int width, const int height,
-                                const bool useColor);
+                                const bool useColor) = 0;
 
 
         void setMainFlags(int w, int h, int bpp, bool fs,
@@ -391,15 +367,9 @@ class Graphics : public gcn::SDLGraphics
 
         bool videoInfo();
 
-        int SDL_FakeUpperBlit(const SDL_Surface *const src,
-                              SDL_Rect *const srcrect,
-                              const SDL_Surface *const dst,
-                              SDL_Rect *dstrect) const;
-
         int mBpp;
         bool mFullscreen;
         bool mHWAccel;
-        BlitMode mBlitMode;
         bool mRedraw;
         bool mDoubleBuffer;
         SDL_Rect mRect;
@@ -407,8 +377,6 @@ class Graphics : public gcn::SDLGraphics
         int mOpenGL;
         bool mEnableResize;
         bool mNoFrame;
-        uint32_t mOldPixel;
-        int mOldAlpha;
         std::string mName;
         int mStartFreeMem;
         bool mSync;
diff --git a/src/graphicsmanager.cpp b/src/graphicsmanager.cpp
index 7628b19fc..3bba8f9af 100644
--- a/src/graphicsmanager.cpp
+++ b/src/graphicsmanager.cpp
@@ -41,6 +41,7 @@
 #include "graphicsvertexes.h"
 #include "logger.h"
 #include "mgl.h"
+#include "sdlgraphics.h"
 
 #include "resources/fboinfo.h"
 #include "resources/imagehelper.h"
@@ -228,7 +229,7 @@ void GraphicsManager::initGraphics(const bool noOpenGL)
         case 0:
             imageHelper = new SDLImageHelper;
             sdlImageHelper = imageHelper;
-            mainGraphics = new Graphics;
+            mainGraphics = new SDLGraphics;
             mUseTextureSampler = false;
             break;
         case 1:
@@ -261,7 +262,7 @@ void GraphicsManager::initGraphics(const bool noOpenGL A_UNUSED)
     // Create the graphics context
     imageHelper = new SDLImageHelper;
     sdlImageHelper = imageHelper;
-    mainGraphics = new Graphics;
+    mainGraphics = new SDLGraphics;
 #endif
 }
 
diff --git a/src/maplayer.cpp b/src/maplayer.cpp
index 980a9a786..81561d94a 100644
--- a/src/maplayer.cpp
+++ b/src/maplayer.cpp
@@ -227,7 +227,7 @@ void MapLayer::updateSDL(Graphics *const graphics, int startX, int startY,
                         row->images.push_back(imgVert);
                         lastImage = img;
                     }
-                    graphics->calcTile(imgVert, px, py);
+                    graphics->calcTileSDL(imgVert, px, py);
                 }
             }
         }
diff --git a/src/mobileopenglgraphics.h b/src/mobileopenglgraphics.h
index 4f96ce1df..c41a15a04 100644
--- a/src/mobileopenglgraphics.h
+++ b/src/mobileopenglgraphics.h
@@ -201,8 +201,6 @@ class MobileOpenGLGraphics final : public Graphics
 
         void setTexturingAndBlending(const bool enable);
 
-        void updateMemoryInfo();
-
         void debugBindTexture(const Image *image);
 
     private:
diff --git a/src/normalopenglgraphics.h b/src/normalopenglgraphics.h
index 9da63c32c..3b6dc0c19 100644
--- a/src/normalopenglgraphics.h
+++ b/src/normalopenglgraphics.h
@@ -212,8 +212,6 @@ class NormalOpenGLGraphics final : public Graphics
 
         void setTexturingAndBlending(const bool enable);
 
-        void updateMemoryInfo();
-
         void debugBindTexture(const Image *const image);
 
     private:
diff --git a/src/nullopenglgraphics.h b/src/nullopenglgraphics.h
index 7f58e1242..73c08b81e 100644
--- a/src/nullopenglgraphics.h
+++ b/src/nullopenglgraphics.h
@@ -209,8 +209,6 @@ class NullOpenGLGraphics final : public Graphics
 
         void setTexturingAndBlending(const bool enable);
 
-        void updateMemoryInfo();
-
         void debugBindTexture(const Image *const image);
 
     private:
diff --git a/src/resources/atlasmanager.cpp b/src/resources/atlasmanager.cpp
index 0f7565ecd..1d7147d72 100644
--- a/src/resources/atlasmanager.cpp
+++ b/src/resources/atlasmanager.cpp
@@ -25,9 +25,9 @@
 #include "resources/atlasmanager.h"
 
 #include "client.h"
-#include "graphics.h"
 #include "graphicsmanager.h"
 #include "logger.h"
+#include "sdlgraphics.h"
 
 #include "utils/mathutils.h"
 #include "utils/physfsrwops.h"
@@ -227,7 +227,7 @@ SDL_Surface *AtlasManager::createSDLAtlas(TextureAtlas *const atlas)
     if (!surface)
         return nullptr;
 
-    Graphics *const graphics = new Graphics();
+    SDLGraphics *const graphics = new SDLGraphics();
     graphics->setTarget(surface);
     graphics->_beginDraw();
 
diff --git a/src/resources/image.h b/src/resources/image.h
index 5ac239471..556109564 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -55,6 +55,7 @@ class Image : public Resource
     friend class Graphics;
     friend class ImageHelper;
     friend class OpenGLImageHelper;
+    friend class SDLGraphics;
     friend class SDLImageHelper;
 #ifdef USE_OPENGL
     friend class AtlasManager;
diff --git a/src/safeopenglgraphics.cpp b/src/safeopenglgraphics.cpp
index 35748f539..2e8666e55 100644
--- a/src/safeopenglgraphics.cpp
+++ b/src/safeopenglgraphics.cpp
@@ -345,10 +345,28 @@ void SafeOpenGLGraphics::calcTile(ImageVertexes *const vert A_UNUSED,
 {
 }
 
+void SafeOpenGLGraphics::calcImagePattern(ImageVertexes *const vert,
+                                          const Image *const image,
+                                          const int x, const int y,
+                                          const int w, const int h) const
+{
+}
+
+void SafeOpenGLGraphics::calcImagePattern(ImageCollection *const vert,
+                                          const Image *const image,
+                                          const int x, const int y,
+                                          const int w, const int h) const
+{
+}
+
 void SafeOpenGLGraphics::drawTile(const ImageVertexes *const vert A_UNUSED)
 {
 }
 
+void SafeOpenGLGraphics::drawTile(const ImageCollection *const vertCol)
+{
+}
+
 void SafeOpenGLGraphics::updateScreen()
 {
     BLOCK_START("Graphics::updateScreen")
@@ -358,6 +376,13 @@ void SafeOpenGLGraphics::updateScreen()
     BLOCK_END("Graphics::updateScreen")
 }
 
+bool SafeOpenGLGraphics::calcWindow(ImageCollection *const vertCol,
+                                    const int x, const int y,
+                                    const int w, const int h,
+                                    const ImageRect &imgRect)
+{
+}
+
 void SafeOpenGLGraphics::_beginDraw()
 {
     glMatrixMode(GL_TEXTURE);
diff --git a/src/safeopenglgraphics.h b/src/safeopenglgraphics.h
index c134caa2d..469c4cda0 100644
--- a/src/safeopenglgraphics.h
+++ b/src/safeopenglgraphics.h
@@ -89,10 +89,27 @@ class SafeOpenGLGraphics final : public Graphics
         void calcTile(ImageCollection *const vertCol,
                       const Image *const image, int x, int y) override;
 
+        void calcImagePattern(ImageVertexes *const vert,
+                              const Image *const image,
+                              const int x, const int y,
+                              const int w, const int h) const;
+
+        void calcImagePattern(ImageCollection *const vert,
+                              const Image *const image,
+                              const int x, const int y,
+                              const int w, const int h) const;
+
         void drawTile(const ImageVertexes *const vert) override;
 
+        void drawTile(const ImageCollection *const vertCol) override;
+
         void updateScreen() override;
 
+        bool calcWindow(ImageCollection *const vertCol,
+                        const int x, const int y,
+                        const int w, const int h,
+                        const ImageRect &imgRect);
+
         void _beginDraw();
 
         void _endDraw();
diff --git a/src/sdlgraphics.cpp b/src/sdlgraphics.cpp
new file mode 100644
index 000000000..81970b0e3
--- /dev/null
+++ b/src/sdlgraphics.cpp
@@ -0,0 +1,773 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2013  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  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
+ *  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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sdlgraphics.h"
+
+#include "main.h"
+
+#include "configuration.h"
+#include "graphicsmanager.h"
+#include "graphicsvertexes.h"
+#include "logger.h"
+
+#include "resources/imagehelper.h"
+
+#include <guichan/sdl/sdlpixel.hpp>
+
+#include <SDL_gfxBlitFunc.h>
+
+#include "debug.h"
+
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+static unsigned int *cR = nullptr;
+static unsigned int *cG = nullptr;
+static unsigned int *cB = nullptr;
+#endif
+
+SDLGraphics::SDLGraphics() :
+    Graphics(),
+    mBlitMode(BLIT_NORMAL),
+    mOldPixel(0),
+    mOldAlpha(0)
+{
+}
+
+SDLGraphics::~SDLGraphics()
+{
+}
+
+bool SDLGraphics::drawRescaledImage(const Image *const image, int srcX, int srcY,
+                                    int dstX, int dstY,
+                                    const int width, const int height,
+                                    const int desiredWidth,
+                                    const int desiredHeight,
+                                    const bool useColor A_UNUSED)
+{
+    FUNC_BLOCK("Graphics::drawRescaledImage", 1)
+    // Check that preconditions for blitting are met.
+    if (!mTarget || !image)
+        return false;
+    if (!image->mSDLSurface)
+        return false;
+
+    Image *const tmpImage = image->SDLgetScaledImage(
+        desiredWidth, desiredHeight);
+
+    if (!tmpImage)
+        return false;
+    if (!tmpImage->mSDLSurface)
+        return false;
+
+    dstX += mClipStack.top().xOffset;
+    dstY += mClipStack.top().yOffset;
+
+    srcX += image->mBounds.x;
+    srcY += image->mBounds.y;
+
+    SDL_Rect dstRect;
+    SDL_Rect srcRect;
+    dstRect.x = static_cast<int16_t>(dstX);
+    dstRect.y = static_cast<int16_t>(dstY);
+    srcRect.x = static_cast<int16_t>(srcX);
+    srcRect.y = static_cast<int16_t>(srcY);
+    srcRect.w = static_cast<uint16_t>(width);
+    srcRect.h = static_cast<uint16_t>(height);
+
+    const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface,
+        &srcRect, mTarget, &dstRect) < 0);
+
+    delete tmpImage;
+
+    return returnValue;
+}
+
+bool SDLGraphics::drawImage2(const Image *const image, int srcX, int srcY,
+                          int dstX, int dstY, const int width,
+                          const int height, const bool useColor A_UNUSED)
+{
+    FUNC_BLOCK("Graphics::drawImage2", 1)
+    // Check that preconditions for blitting are met.
+    if (!mTarget || !image || !image->mSDLSurface)
+        return false;
+
+    dstX += mClipStack.top().xOffset;
+    dstY += mClipStack.top().yOffset;
+
+    srcX += image->mBounds.x;
+    srcY += image->mBounds.y;
+
+    SDL_Rect dstRect;
+    SDL_Rect srcRect;
+    dstRect.x = static_cast<int16_t>(dstX);
+    dstRect.y = static_cast<int16_t>(dstY);
+    srcRect.x = static_cast<int16_t>(srcX);
+    srcRect.y = static_cast<int16_t>(srcY);
+    srcRect.w = static_cast<uint16_t>(width);
+    srcRect.h = static_cast<uint16_t>(height);
+
+    if (mBlitMode == BLIT_NORMAL)
+    {
+        return !(SDL_BlitSurface(image->mSDLSurface, &srcRect,
+                                 mTarget, &dstRect) < 0);
+    }
+    else
+    {
+        return !(SDL_gfxBlitRGBA(image->mSDLSurface, &srcRect,
+                                 mTarget, &dstRect) < 0);
+    }
+}
+
+void SDLGraphics::drawImagePattern(const Image *const image,
+                                   const int x, const int y,
+                                   const int w, const int h)
+{
+    FUNC_BLOCK("Graphics::drawImagePattern", 1)
+    // Check that preconditions for blitting are met.
+    if (!mTarget || !image)
+        return;
+    if (!image->mSDLSurface)
+        return;
+
+    const int iw = image->mBounds.w;
+    const int ih = image->mBounds.h;
+
+    if (iw == 0 || ih == 0)
+        return;
+
+    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        const int srcY = image->mBounds.y;
+        const int dstY = y + py + mClipStack.top().yOffset;
+
+        for (int px = 0; px < w; px += iw)  // X position on pattern plane
+        {
+            const int dw = (px + iw >= w) ? w - px : iw;
+            const int srcX = image->mBounds.x;
+            const int dstX = x + px + mClipStack.top().xOffset;
+
+            SDL_Rect dstRect;
+            SDL_Rect srcRect;
+            dstRect.x = static_cast<int16_t>(dstX);
+            dstRect.y = static_cast<int16_t>(dstY);
+            srcRect.x = static_cast<int16_t>(srcX);
+            srcRect.y = static_cast<int16_t>(srcY);
+            srcRect.w = static_cast<uint16_t>(dw);
+            srcRect.h = static_cast<uint16_t>(dh);
+
+            SDL_BlitSurface(image->mSDLSurface, &srcRect, mTarget, &dstRect);
+        }
+    }
+}
+
+void SDLGraphics::drawRescaledImagePattern(const Image *const image,
+                                           const int x, const int y,
+                                           const int w, const int h,
+                                           const int scaledWidth,
+                                           const int scaledHeight)
+{
+    // Check that preconditions for blitting are met.
+    if (!mTarget || !image)
+        return;
+    if (!image->mSDLSurface)
+        return;
+
+    if (scaledHeight == 0 || scaledWidth == 0)
+        return;
+
+    Image *const tmpImage = image->SDLgetScaledImage(
+        scaledWidth, scaledHeight);
+    if (!tmpImage)
+        return;
+
+    const int iw = tmpImage->mBounds.w;
+    const int ih = tmpImage->mBounds.h;
+
+    if (iw == 0 || ih == 0)
+        return;
+
+    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        const int srcY = tmpImage->mBounds.y;
+        const int dstY = y + py + mClipStack.top().yOffset;
+
+        for (int px = 0; px < w; px += iw)  // X position on pattern plane
+        {
+            const int dw = (px + iw >= w) ? w - px : iw;
+            const int srcX = tmpImage->mBounds.x;
+            const int dstX = x + px + mClipStack.top().xOffset;
+
+            SDL_Rect dstRect;
+            SDL_Rect srcRect;
+            dstRect.x = static_cast<int16_t>(dstX);
+            dstRect.y = static_cast<int16_t>(dstY);
+            srcRect.x = static_cast<int16_t>(srcX);
+            srcRect.y = static_cast<int16_t>(srcY);
+            srcRect.w = static_cast<uint16_t>(dw);
+            srcRect.h = static_cast<uint16_t>(dh);
+
+            SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect,
+                            mTarget, &dstRect);
+        }
+    }
+
+    delete tmpImage;
+}
+
+void SDLGraphics::calcImagePattern(ImageVertexes* const vert,
+                                   const Image *const image,
+                                   const int x, const int y,
+                                   const int w, const int h) const
+{
+    // Check that preconditions for blitting are met.
+    if (!vert || !mTarget || !image || !image->mSDLSurface)
+        return;
+
+    const int iw = image->mBounds.w;
+    const int ih = image->mBounds.h;
+
+    if (iw == 0 || ih == 0)
+        return;
+
+    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        const int srcY = image->mBounds.y;
+        const int dstY = y + py + mClipStack.top().yOffset;
+
+        for (int px = 0; px < w; px += iw)  // X position on pattern plane
+        {
+            const int dw = (px + iw >= w) ? w - px : iw;
+            const int srcX = image->mBounds.x;
+            const int dstX = x + px + mClipStack.top().xOffset;
+
+            DoubleRect *const r = new DoubleRect();
+            SDL_Rect &dstRect = r->dst;
+            SDL_Rect &srcRect = r->src;
+            dstRect.x = static_cast<int16_t>(dstX);
+            dstRect.y = static_cast<int16_t>(dstY);
+            srcRect.x = static_cast<int16_t>(srcX);
+            srcRect.y = static_cast<int16_t>(srcY);
+            srcRect.w = static_cast<uint16_t>(dw);
+            srcRect.h = static_cast<uint16_t>(dh);
+
+            if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect,
+                mTarget, &dstRect) == 1)
+            {
+                vert->sdl.push_back(r);
+            }
+            else
+            {
+                delete r;
+            }
+        }
+    }
+}
+
+void SDLGraphics::calcImagePattern(ImageCollection* const vertCol,
+                                   const Image *const image,
+                                   const int x, const int y,
+                                   const int w, const int h) const
+{
+    ImageVertexes *vert = nullptr;
+    if (vertCol->currentImage != image)
+    {
+        vert = new ImageVertexes();
+        vertCol->currentImage = image;
+        vertCol->currentVert = vert;
+        vert->image = image;
+        vertCol->draws.push_back(vert);
+    }
+    else
+    {
+        vert = vertCol->currentVert;
+    }
+
+    calcImagePattern(vert, image, x, y, w, h);
+}
+
+void SDLGraphics::calcTile(ImageVertexes *const vert,
+                           const Image *const image,
+                           int x, int y) const
+{
+    vert->image = image;
+    calcTileSDL(vert, x, y);
+}
+
+void SDLGraphics::calcTileSDL(ImageVertexes *const vert, int x, int y) const
+{
+    // Check that preconditions for blitting are met.
+    if (!vert || !vert->image || !vert->image->mSDLSurface)
+        return;
+
+    const Image *const image = vert->image;
+
+    x += mClipStack.top().xOffset;
+    y += mClipStack.top().yOffset;
+
+    DoubleRect *rect = new DoubleRect();
+
+    rect->dst.x = static_cast<int16_t>(x);
+    rect->dst.y = static_cast<int16_t>(y);
+    rect->src.x = static_cast<int16_t>(image->mBounds.x);
+    rect->src.y = static_cast<int16_t>(image->mBounds.y);
+    rect->src.w = static_cast<uint16_t>(image->mBounds.w);
+    rect->src.h = static_cast<uint16_t>(image->mBounds.h);
+    if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src,
+        mTarget, &rect->dst) == 1)
+    {
+        vert->sdl.push_back(rect);
+    }
+    else
+    {
+        delete rect;
+    }
+}
+
+void SDLGraphics::calcTile(ImageCollection *const vertCol,
+                           const Image *const image,
+                           int x, int y)
+{
+    if (vertCol->currentImage != image)
+    {
+        ImageVertexes *const vert = new ImageVertexes();
+        vertCol->currentImage = image;
+        vertCol->currentVert = vert;
+        vert->image = image;
+        vertCol->draws.push_back(vert);
+        calcTileSDL(vert, x, y);
+    }
+    else
+    {
+        calcTileSDL(vertCol->currentVert, x, y);
+    }
+}
+
+void SDLGraphics::drawTile(const ImageCollection *const vertCol)
+{
+    const ImageVertexesVector &draws = vertCol->draws;
+    const ImageCollectionCIter it_end = draws.end();
+    for (ImageCollectionCIter it = draws.begin(); it != it_end; ++ it)
+    {
+        const ImageVertexes *const vert = *it;
+        const Image *const img = vert->image;
+        const DoubleRects *const rects = &vert->sdl;
+        DoubleRects::const_iterator it2 = rects->begin();
+        const DoubleRects::const_iterator it2_end = rects->end();
+        while (it2 != it2_end)
+        {
+            SDL_LowerBlit(img->mSDLSurface, &(*it2)->src,
+                mTarget, &(*it2)->dst);
+            ++ it2;
+        }
+    }
+}
+
+void SDLGraphics::drawTile(const ImageVertexes *const vert)
+{
+    // vert and img must be != 0
+    const Image *const img = vert->image;
+    const DoubleRects *const rects = &vert->sdl;
+    DoubleRects::const_iterator it = rects->begin();
+    const DoubleRects::const_iterator it_end = rects->end();
+    while (it != it_end)
+    {
+        SDL_LowerBlit(img->mSDLSurface, &(*it)->src, mTarget, &(*it)->dst);
+        ++ it;
+    }
+}
+
+void SDLGraphics::updateScreen()
+{
+    BLOCK_START("Graphics::updateScreen")
+    if (mDoubleBuffer)
+    {
+        SDL_Flip(mTarget);
+    }
+    else
+    {
+        SDL_UpdateRects(mTarget, 1, &mRect);
+//        SDL_UpdateRect(mTarget, 0, 0, 0, 0);
+    }
+    BLOCK_END("Graphics::updateScreen")
+}
+
+SDL_Surface *SDLGraphics::getScreenshot()
+{
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    const int rmask = 0xff000000;
+    const int gmask = 0x00ff0000;
+    const int bmask = 0x0000ff00;
+#else
+    const int rmask = 0x000000ff;
+    const int gmask = 0x0000ff00;
+    const int bmask = 0x00ff0000;
+#endif
+    const int amask = 0x00000000;
+
+    SDL_Surface *const screenshot = SDL_CreateRGBSurface(SDL_SWSURFACE,
+        mTarget->w, mTarget->h, 24, rmask, gmask, bmask, amask);
+
+    if (screenshot)
+        SDL_BlitSurface(mTarget, nullptr, screenshot, nullptr);
+
+    return screenshot;
+}
+
+bool SDLGraphics::drawNet(const int x1, const int y1,
+                          const int x2, const int y2,
+                          const int width, const int height)
+{
+    for (int y = y1; y < y2; y += height)
+        drawLine(x1, y, x2, y);
+
+    for (int x = x1; x < x2; x += width)
+        drawLine(x, y1, x, y2);
+
+    return true;
+}
+
+bool SDLGraphics::calcWindow(ImageCollection *const vertCol,
+                             const int x, const int y,
+                             const int w, const int h,
+                             const ImageRect &imgRect)
+{
+    ImageVertexes *vert = nullptr;
+    Image *const image = imgRect.grid[4];
+    if (vertCol->currentImage != image)
+    {
+        vert = new ImageVertexes();
+        vertCol->currentImage = image;
+        vertCol->currentVert = vert;
+        vert->image = image;
+        vertCol->draws.push_back(vert);
+    }
+    else
+    {
+        vert = vertCol->currentVert;
+    }
+
+    return calcImageRect(vert, x, y, w, h,
+        imgRect.grid[0], imgRect.grid[2], imgRect.grid[6], imgRect.grid[8],
+        imgRect.grid[1], imgRect.grid[5], imgRect.grid[7], imgRect.grid[3],
+        imgRect.grid[4]);
+}
+
+int SDLGraphics::SDL_FakeUpperBlit(const SDL_Surface *const src,
+                                SDL_Rect *const srcrect,
+                                const SDL_Surface *const dst,
+                                SDL_Rect *dstrect) const
+{
+    SDL_Rect fulldst;
+    int srcx, srcy, w, h;
+
+    // Make sure the surfaces aren't locked
+    if (!src || !dst)
+        return -1;
+
+    if (src->locked || dst->locked)
+        return -1;
+
+    // If the destination rectangle is nullptr, use the entire dest surface
+    if (!dstrect)
+    {
+        fulldst.x = 0;
+        fulldst.y = 0;
+        dstrect = &fulldst;
+    }
+
+    // clip the source rectangle to the source surface
+    if (srcrect)
+    {
+        srcx = srcrect->x;
+        w = srcrect->w;
+        if (srcx < 0)
+        {
+            w += srcx;
+            dstrect->x -= static_cast<int16_t>(srcx);
+            srcx = 0;
+        }
+        int maxw = src->w - srcx;
+        if (maxw < w)
+            w = maxw;
+
+        srcy = srcrect->y;
+        h = srcrect->h;
+        if (srcy < 0)
+        {
+            h += srcy;
+            dstrect->y -= static_cast<int16_t>(srcy);
+            srcy = 0;
+        }
+        int maxh = src->h - srcy;
+        if (maxh < h)
+            h = maxh;
+    }
+    else
+    {
+        srcx = 0;
+        srcy = 0;
+        w = src->w;
+        h = src->h;
+    }
+
+    // clip the destination rectangle against the clip rectangle
+    {
+        const SDL_Rect *const clip = &dst->clip_rect;
+        int dx = clip->x - dstrect->x;
+        if (dx > 0)
+        {
+            w -= dx;
+            dstrect->x += static_cast<int16_t>(dx);
+            srcx += dx;
+        }
+        dx = dstrect->x + w - clip->x - clip->w;
+        if (dx > 0)
+            w -= dx;
+
+        int dy = clip->y - dstrect->y;
+        if (dy > 0)
+        {
+            h -= dy;
+            dstrect->y += static_cast<int16_t>(dy);
+            srcy += dy;
+        }
+        dy = dstrect->y + h - clip->y - clip->h;
+        if (dy > 0)
+            h -= dy;
+    }
+
+    if (w > 0 && h > 0)
+    {
+        if (srcrect)
+        {
+            srcrect->x = static_cast<int16_t>(srcx);
+            srcrect->y = static_cast<int16_t>(srcy);
+            srcrect->w = static_cast<int16_t>(w);
+            srcrect->h = static_cast<int16_t>(h);
+        }
+        dstrect->w = static_cast<int16_t>(w);
+        dstrect->h = static_cast<int16_t>(h);
+
+        return 1;
+//        return SDL_LowerBlit(src, &sr, dst, dstrect);
+    }
+    dstrect->w = dstrect->h = 0;
+    return 0;
+}
+
+void SDLGraphics::fillRectangle(const gcn::Rectangle& rectangle)
+{
+    FUNC_BLOCK("Graphics::fillRectangle", 1)
+    if (mClipStack.empty())
+        return;
+
+    const gcn::ClipRectangle& top = mClipStack.top();
+
+    gcn::Rectangle area = rectangle;
+    area.x += top.xOffset;
+    area.y += top.yOffset;
+
+    if (!area.isIntersecting(top))
+        return;
+
+    if (mAlpha)
+    {
+        const int x1 = area.x > top.x ? area.x : top.x;
+        const int y1 = area.y > top.y ? area.y : top.y;
+        const int x2 = area.x + area.width < top.x + top.width ?
+            area.x + area.width : top.x + top.width;
+        const int y2 = area.y + area.height < top.y + top.height ?
+            area.y + area.height : top.y + top.height;
+        int x, y;
+
+        SDL_LockSurface(mTarget);
+
+        const int bpp = mTarget->format->BytesPerPixel;
+        const uint32_t pixel = SDL_MapRGB(mTarget->format,
+            static_cast<uint8_t>(mColor.r), static_cast<uint8_t>(mColor.g),
+            static_cast<uint8_t>(mColor.b));
+
+        switch (bpp)
+        {
+            case 1:
+                for (y = y1; y < y2; y++)
+                {
+                    uint8_t *const p = static_cast<uint8_t *>(mTarget->pixels)
+                        + y * mTarget->pitch;
+                    for (x = x1; x < x2; x++)
+                        *(p + x) = static_cast<uint8_t>(pixel);
+                }
+                break;
+            case 2:
+                for (y = y1; y < y2; y++)
+                {
+                    uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
+                        + y * mTarget->pitch;
+                    for (x = x1; x < x2; x++)
+                    {
+                        uint8_t *const p = p0 + x * 2;
+                        *reinterpret_cast<uint16_t *>(p) = gcn::SDLAlpha16(
+                            static_cast<uint16_t>(pixel),
+                            *reinterpret_cast<uint16_t *>(p),
+                            static_cast<uint8_t>(mColor.a), mTarget->format);
+                    }
+                }
+                break;
+            case 3:
+            {
+                const int ca = 255 - mColor.a;
+                const int cr = mColor.r * mColor.a;
+                const int cg = mColor.g * mColor.a;
+                const int cb = mColor.b * mColor.a;
+
+                for (y = y1; y < y2; y++)
+                {
+                    uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
+                        + y * mTarget->pitch;
+                    for (x = x1; x < x2; x++)
+                    {
+                        uint8_t *const p = p0 + x * 3;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+                        p[2] = static_cast<uint8_t>((p[2] * ca + cb) >> 8);
+                        p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
+                        p[0] = static_cast<uint8_t>((p[0] * ca + cr) >> 8);
+#else
+                        p[0] = static_cast<uint8_t>((p[0] * ca + cb) >> 8);
+                        p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
+                        p[2] = static_cast<uint8_t>((p[2] * ca + cr) >> 8);
+#endif
+                    }
+                }
+                break;
+            }
+            case 4:
+            {
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+                const unsigned pb = (pixel & 0xff) * mColor.a;
+                const unsigned pg = (pixel & 0xff00) * mColor.a;
+                const unsigned pr = (pixel & 0xff0000) * mColor.a;
+                const unsigned a1 = (255 - mColor.a);
+
+                for (y = y1; y < y2; y++)
+                {
+                    uint8_t *p0 = static_cast<uint8_t *>(mTarget->pixels)
+                        + y * mTarget->pitch;
+                    for (x = x1; x < x2; x++)
+                    {
+                        uint8_t *p = p0 + x * 4;
+                        uint32_t dst = *reinterpret_cast<uint32_t *>(p);
+                        const unsigned int b = (pb + (dst & 0xff) * a1) >> 8;
+                        const unsigned int g = (pg + (dst & 0xff00) * a1) >> 8;
+                        const unsigned int r = (pr
+                            + (dst & 0xff0000) * a1) >> 8;
+
+                        *reinterpret_cast<uint32_t *>(p) = ((b & 0xff)
+                            | (g & 0xff00) | (r & 0xff0000));
+                    }
+                }
+#else
+                if (!cR)
+                {
+                    cR = new unsigned int[0x100];
+                    cG = new unsigned int[0x100];
+                    cB = new unsigned int[0x100];
+                    mOldPixel = 0;
+                    mOldAlpha = mColor.a;
+                }
+
+                const SDL_PixelFormat * const format = mTarget->format;
+                const unsigned rMask = format->Rmask;
+                const unsigned gMask = format->Gmask;
+                const unsigned bMask = format->Bmask;
+//                const unsigned aMask = format->Amask;
+                unsigned rShift = rMask / 0xff;
+                unsigned gShift = gMask / 0xff;
+                unsigned bShift = bMask / 0xff;
+                if (!rShift)
+                    rShift = 1;
+                if (!gShift)
+                    gShift = 1;
+                if (!bShift)
+                    bShift = 1;
+                if (pixel != mOldPixel || mColor.a != mOldAlpha)
+                {
+                    const unsigned pb = (pixel & bMask) * mColor.a;
+                    const unsigned pg = (pixel & gMask) * mColor.a;
+                    const unsigned pr = (pixel & rMask) * mColor.a;
+                    const unsigned a0 = (255 - mColor.a);
+
+                    const unsigned int a1 = a0 * bShift;
+                    const unsigned int a2 = a0 * gShift;
+                    const unsigned int a3 = a0 * rShift;
+
+                    for (int f = 0; f <= 0xff; f ++)
+                    {
+                        cB[f] = ((pb + f * a1) >> 8) & bMask;
+                        cG[f] = ((pg + f * a2) >> 8) & gMask;
+                        cR[f] = ((pr + f * a3) >> 8) & rMask;
+                    }
+
+                    mOldPixel = pixel;
+                    mOldAlpha = mColor.a;
+                }
+
+                for (y = y1; y < y2; y++)
+                {
+                    uint32_t *const p0 = reinterpret_cast<uint32_t*>(
+                        static_cast<uint8_t*>(mTarget->pixels)
+                        + y * mTarget->pitch);
+                    for (x = x1; x < x2; x++)
+                    {
+                        uint32_t *const p = p0 + x;
+                        const uint32_t dst = *p;
+                        *p = cB[dst & bMask / bShift]
+                            | cG[(dst & gMask) / gShift]
+                            | cR[(dst & rMask) / rShift];
+                    }
+                }
+#endif
+                break;
+            }
+            default:
+                break;
+        }
+
+        SDL_UnlockSurface(mTarget);
+    }
+    else
+    {
+        SDL_Rect rect;
+        rect.x = static_cast<int16_t>(area.x);
+        rect.y = static_cast<int16_t>(area.y);
+        rect.w = static_cast<uint16_t>(area.width);
+        rect.h = static_cast<uint16_t>(area.height);
+
+        const uint32_t color = SDL_MapRGBA(mTarget->format,
+            static_cast<int8_t>(mColor.r),
+            static_cast<int8_t>(mColor.g),
+            static_cast<int8_t>(mColor.b),
+            static_cast<int8_t>(mColor.a));
+        SDL_FillRect(mTarget, &rect, color);
+    }
+}
diff --git a/src/sdlgraphics.h b/src/sdlgraphics.h
new file mode 100644
index 000000000..823ee9a43
--- /dev/null
+++ b/src/sdlgraphics.h
@@ -0,0 +1,140 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2013  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  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
+ *  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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDLGRAPHICS_H
+#define SDLGRAPHICS_H
+
+#include "graphics.h"
+
+#include "localconsts.h"
+
+class Image;
+class ImageCollection;
+class ImageVertexes;
+class MapLayer;
+
+struct SDL_Surface;
+
+/**
+ * A central point of control for graphics.
+ */
+class SDLGraphics : public Graphics
+{
+    public:
+        enum BlitMode
+        {
+            BLIT_NORMAL = 0,
+            BLIT_GFX
+        };
+
+        /**
+         * Constructor.
+         */
+        SDLGraphics();
+
+        A_DELETE_COPY(SDLGraphics)
+
+        /**
+         * Destructor.
+         */
+        virtual ~SDLGraphics();
+
+        virtual bool drawRescaledImage(const Image *const image, int srcX,
+                                       int srcY, int dstX, int dstY,
+                                       const int width, const int height,
+                                       const int desiredWidth,
+                                       const int desiredHeight,
+                                       const bool useColor = false);
+
+        virtual void drawImagePattern(const Image *const image,
+                                      const int x, const int y,
+                                      const int w, const int h);
+
+        virtual void drawRescaledImagePattern(const Image *const image,
+                                              const int x, const int y,
+                                              const int w, const int h,
+                                              const int scaledWidth,
+                                              const int scaledHeight);
+
+        virtual void calcImagePattern(ImageVertexes *const vert,
+                                      const Image *const image,
+                                      const int x, const int y,
+                                      const int w, const int h) const;
+
+        virtual void calcImagePattern(ImageCollection *const vert,
+                                      const Image *const image,
+                                      const int x, const int y,
+                                      const int w, const int h) const;
+
+        virtual void calcTile(ImageVertexes *const vert,
+                              const Image *const image, int x, int y) const;
+
+        virtual void calcTileSDL(ImageVertexes *const vert,
+                                 int x, int y) const;
+
+        virtual void calcTile(ImageCollection *const vertCol,
+                              const Image *const image,
+                              int x, int y);
+
+        virtual void drawTile(const ImageVertexes *const vert);
+
+        virtual void drawTile(const ImageCollection *const vertCol);
+
+        virtual void updateScreen();
+
+        virtual SDL_Surface *getScreenshot() A_WARN_UNUSED;
+
+        virtual bool drawNet(const int x1, const int y1,
+                             const int x2, const int y2,
+                             const int width, const int height);
+
+        virtual bool calcWindow(ImageCollection *const vertCol,
+                                const int x, const int y,
+                                const int w, const int h,
+                                const ImageRect &imgRect);
+
+        void setBlitMode(const BlitMode mode)
+        { mBlitMode = mode; }
+
+        BlitMode getBlitMode() const A_WARN_UNUSED
+        { return mBlitMode; }
+
+        void fillRectangle(const gcn::Rectangle& rectangle) override;
+
+    protected:
+        virtual bool drawImage2(const Image *const image,
+                                int srcX, int srcY,
+                                int dstX, int dstY,
+                                const int width, const int height,
+                                const bool useColor);
+
+        int SDL_FakeUpperBlit(const SDL_Surface *const src,
+                              SDL_Rect *const srcrect,
+                              const SDL_Surface *const dst,
+                              SDL_Rect *dstrect) const;
+
+        BlitMode mBlitMode;
+        uint32_t mOldPixel;
+        int mOldAlpha;
+};
+
+#endif  // SDLGRAPHICS_H