add software renderer for SDL2.

before it used default renderer with software flags.

10 files changed, 1761 insertions, 14 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6e2aede86..26bd600d2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -490,6 +490,8 @@ SET(SRCS
     resources/resourcemanager.h
     resources/sdl2imagehelper.cpp
     resources/sdl2imagehelper.h
+    resources/sdl2softwareimagehelper.cpp
+    resources/sdl2softwareimagehelper.h
     resources/sdlimagehelper.cpp
     resources/sdlimagehelper.h
     resources/sdlmusic.cpp
@@ -706,6 +708,8 @@ SET(SRCS
     render/safeopenglgraphics.h
     render/sdl2graphics.cpp
     render/sdl2graphics.h
+    render/sdl2softwaregraphics.cpp
+    render/sdl2softwaregraphics.h
     render/sdlgraphics.cpp
     render/sdlgraphics.h
     sdlshared.h
diff --git a/src/Makefile.am b/src/Makefile.am
index 84a9444a9..8332f02cd 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -32,7 +32,9 @@ endif
 if USE_SDL2
 manaplus_CXXFLAGS += -I$(srcdir)/sdl2gfx -DUSE_SDL2
 manaplus_SOURCES += sdl2gfx/SDL_framerate.c \
-	      sdl2gfx/SDL_framerate.h
+	      sdl2gfx/SDL_framerate.h \
+	      sdl2gfx/SDL_rotozoom.c \
+	      sdl2gfx/SDL_rotozoom.h
 endif
 
 if USE_INTERNALGUICHAN
@@ -499,6 +501,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \
 	      resources/resourcemanager.h \
 	      resources/sdl2imagehelper.cpp \
 	      resources/sdl2imagehelper.h \
+	      resources/sdl2softwareimagehelper.cpp \
+	      resources/sdl2softwareimagehelper.h \
 	      resources/sdlimagehelper.cpp \
 	      resources/sdlimagehelper.h \
 	      resources/sdlmusic.cpp \
@@ -715,6 +719,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \
 	      render/safeopenglgraphics.h \
 	      render/sdl2graphics.cpp \
 	      render/sdl2graphics.h \
+	      render/sdl2softwaregraphics.cpp \
+	      render/sdl2softwaregraphics.h \
 	      render/sdlgraphics.cpp \
 	      render/sdlgraphics.h \
 	      sdlshared.h \
diff --git a/src/graphicsmanager.cpp b/src/graphicsmanager.cpp
index 1c6f81233..471bcb630 100644
--- a/src/graphicsmanager.cpp
+++ b/src/graphicsmanager.cpp
@@ -43,11 +43,13 @@
 
 #include "render/graphics.h"
 #include "render/renderers.h"
+#include "render/sdl2softwaregraphics.h"
 #include "render/sdlgraphics.h"
 
 #include "resources/fboinfo.h"
 #include "resources/imagehelper.h"
 #include "resources/openglimagehelper.h"
+#include "resources/sdl2softwareimagehelper.h"
 #include "resources/sdlimagehelper.h"
 #include "resources/surfaceimagehelper.h"
 
@@ -231,13 +233,15 @@ void GraphicsManager::initGraphics(const bool noOpenGL)
     switch (useOpenGL)
     {
         case RENDER_SOFTWARE:
-            imageHelper = new SDLImageHelper;
 #ifdef USE_SDL2
+            imageHelper = new SDL2SoftwareImageHelper;
             surfaceImageHelper = new SurfaceImageHelper;
+            mainGraphics = new SDL2SoftwareGraphics;
 #else
+            imageHelper = new SDLImageHelper;
             surfaceImageHelper = imageHelper;
-#endif
             mainGraphics = new SDLGraphics;
+#endif
             mUseTextureSampler = false;
             break;
         case RENDER_NORMAL_OPENGL:
diff --git a/src/gui/widgets/desktop.cpp b/src/gui/widgets/desktop.cpp
index 93b0a96e7..07a49c420 100644
--- a/src/gui/widgets/desktop.cpp
+++ b/src/gui/widgets/desktop.cpp
@@ -99,7 +99,6 @@ void Desktop::draw(gcn::Graphics *graphics)
             g->fillRectangle(gcn::Rectangle(0, 0, width, height));
         }
 
-#ifndef USE_SDL2
         if (imageHelper->useOpenGL() == RENDER_SOFTWARE)
         {
             g->drawImage(mWallpaper,
@@ -107,7 +106,6 @@ void Desktop::draw(gcn::Graphics *graphics)
                 (height - wallpHeight) / 2);
         }
         else
-#endif
         {
             g->drawRescaledImage(mWallpaper, 0, 0, 0, 0,
                 wallpWidth, wallpHeight,
@@ -150,11 +148,7 @@ void Desktop::setBestFittingWallpaper()
         const int width = rect.width;
         const int height = rect.height;
 
-#ifdef USE_SDL2
-        if (false &&
-#else
         if (imageHelper->useOpenGL() == RENDER_SOFTWARE &&
-#endif
             (nWallPaper->getWidth() != width
             || nWallPaper->getHeight() != height))
         {
diff --git a/src/render/sdl2softwaregraphics.cpp b/src/render/sdl2softwaregraphics.cpp
new file mode 100644
index 000000000..857909636
--- /dev/null
+++ b/src/render/sdl2softwaregraphics.cpp
@@ -0,0 +1,1283 @@
+/*
+ *  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/>.
+ */
+
+#ifdef USE_SDL2
+
+#include "render/sdl2softwaregraphics.h"
+
+#include "main.h"
+
+#include "configuration.h"
+#include "graphicsmanager.h"
+#include "graphicsvertexes.h"
+#include "logger.h"
+
+#include "resources/imagehelper.h"
+#include "resources/sdl2imagehelper.h"
+
+#include <guichan/sdl/sdlpixel.hpp>
+
+#include "utils/sdlcheckutils.h"
+
+#include <SDL.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
+
+SDL2SoftwareGraphics::SDL2SoftwareGraphics() :
+    Graphics(),
+    mRendererFlags(SDL_RENDERER_SOFTWARE),
+    mSurface(nullptr),
+    mOldPixel(0),
+    mOldAlpha(0)
+{
+    mOpenGL = RENDER_SOFTWARE;
+    mName = "Software";
+}
+
+SDL2SoftwareGraphics::~SDL2SoftwareGraphics()
+{
+}
+
+bool SDL2SoftwareGraphics::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 (!mSurface || !image)
+        return false;
+    if (!image->mSDLSurface)
+        return false;
+
+    Image *const tmpImage = image->SDLgetScaledImage(
+        desiredWidth, desiredHeight);
+
+    if (!tmpImage)
+        return false;
+    if (!tmpImage->mSDLSurface)
+        return false;
+
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const SDL_Rect &bounds = image->mBounds;
+
+    SDL_Rect srcRect =
+    {
+        static_cast<int16_t>(srcX + bounds.x),
+        static_cast<int16_t>(srcY + bounds.y),
+        static_cast<uint16_t>(width),
+        static_cast<uint16_t>(height)
+    };
+
+    SDL_Rect dstRect =
+    {
+        static_cast<int16_t>(dstX + top.xOffset),
+        static_cast<int16_t>(dstY + top.yOffset),
+        0,
+        0
+    };
+
+    const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface,
+        &srcRect, mSurface, &dstRect) < 0);
+
+    delete tmpImage;
+
+    return returnValue;
+}
+
+bool SDL2SoftwareGraphics::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 (!mSurface || !image || !image->mSDLSurface)
+        return false;
+
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const SDL_Rect &bounds = image->mBounds;
+
+
+    SDL_Surface *const src = image->mSDLSurface;
+
+    srcX += bounds.x;
+    srcY += bounds.y;
+    dstX += top.xOffset;
+    dstY += top.yOffset;
+
+    int w = width;
+    int h = height;
+    if (srcX < 0)
+    {
+        w += srcX;
+        dstX -= static_cast<int16_t>(srcX);
+        srcX = 0;
+    }
+    const int maxw = src->w - srcX;
+    if (maxw < w)
+        w = maxw;
+
+    if (srcY < 0)
+    {
+        h += srcY;
+        dstY -= static_cast<int16_t>(srcY);
+        srcY = 0;
+    }
+    const int maxh = src->h - srcY;
+    if (maxh < h)
+        h = maxh;
+
+    const SDL_Rect *const clip = &mSurface->clip_rect;
+    const int clipX = clip->x;
+    const int clipY = clip->y;
+    int dx = clipX - dstX;
+    if (dx > 0)
+    {
+        w -= dx;
+        dstX += static_cast<int16_t>(dx);
+        srcX += dx;
+    }
+    dx = dstX + w - clipX - clip->w;
+    if (dx > 0)
+        w -= dx;
+
+    int dy = clipY - dstY;
+    if (dy > 0)
+    {
+        h -= dy;
+        dstY += static_cast<int16_t>(dy);
+        srcY += dy;
+    }
+    dy = dstY + h - clipY - clip->h;
+    if (dy > 0)
+        h -= dy;
+
+    if (w > 0 && h > 0)
+    {
+        SDL_Rect srcRect =
+        {
+            static_cast<int16_t>(srcX),
+            static_cast<int16_t>(srcY),
+            static_cast<uint16_t>(w),
+            static_cast<uint16_t>(h)
+        };
+
+        SDL_Rect dstRect =
+        {
+            static_cast<int16_t>(dstX),
+            static_cast<int16_t>(dstY),
+            static_cast<uint16_t>(w),
+            static_cast<uint16_t>(h)
+        };
+
+        return SDL_LowerBlit(src, &srcRect, mSurface, &dstRect);
+    }
+    return 0;
+}
+
+void SDL2SoftwareGraphics::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 (!mSurface || !image)
+        return;
+    if (!image->mSDLSurface)
+        return;
+
+    const SDL_Rect &bounds = image->mBounds;
+    const int iw = bounds.w;
+    const int ih = bounds.h;
+    if (iw == 0 || ih == 0)
+        return;
+
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const int xOffset = top.xOffset + x;
+    const int yOffset = top.yOffset + y;
+    const int srcX = bounds.x;
+    const int srcY = bounds.y;
+    SDL_Surface *const src = image->mSDLSurface;
+    const SDL_Rect *const clip = &mSurface->clip_rect;
+    const int clipX = clip->x;
+    const int clipY = clip->y;
+
+    for (int py = 0; py < h; py += ih)
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        int dstY = py + yOffset;
+        int y2 = srcY;
+        int h2 = dh;
+        if (y2 < 0)
+        {
+            h2 += y2;
+            dstY -= static_cast<int16_t>(y2);
+            y2 = 0;
+        }
+        const int maxh = src->h - y2;
+        if (maxh < h2)
+            h2 = maxh;
+
+        int dy = clipY - dstY;
+        if (dy > 0)
+        {
+            h2 -= dy;
+            dstY += static_cast<int16_t>(dy);
+            y2 += dy;
+        }
+        dy = dstY + h2 - clipY - clip->h;
+        if (dy > 0)
+            h2 -= dy;
+
+        if (h2 > 0)
+        {
+            for (int px = 0; px < w; px += iw)
+            {
+                const int dw = (px + iw >= w) ? w - px : iw;
+                int dstX = px + xOffset;
+                int x2 = srcX;
+                int w2 = dw;
+                if (x2 < 0)
+                {
+                    w2 += x2;
+                    dstX -= static_cast<int16_t>(x2);
+                    x2 = 0;
+                }
+                const int maxw = src->w - x2;
+                if (maxw < w2)
+                    w2 = maxw;
+
+                int dx = clipX - dstX;
+                if (dx > 0)
+                {
+                    w2 -= dx;
+                    dstX += static_cast<int16_t>(dx);
+                    x2 += dx;
+                }
+                dx = dstX + w2 - clipX - clip->w;
+                if (dx > 0)
+                    w2 -= dx;
+
+                if (w2 > 0)
+                {
+                    SDL_Rect srcRect =
+                    {
+                        static_cast<int16_t>(x2),
+                        static_cast<int16_t>(y2),
+                        static_cast<uint16_t>(w2),
+                        static_cast<uint16_t>(h2)
+                    };
+
+                    SDL_Rect dstRect =
+                    {
+                        static_cast<int16_t>(dstX),
+                        static_cast<int16_t>(dstY),
+                        static_cast<uint16_t>(w2),
+                        static_cast<uint16_t>(h2)
+                    };
+
+                    SDL_LowerBlit(src, &srcRect, mSurface, &dstRect);
+                }
+
+//            SDL_BlitSurface(image->mSDLSurface, &srcRect, mWindow, &dstRect);
+            }
+        }
+    }
+}
+
+void SDL2SoftwareGraphics::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 (!mSurface || !image)
+        return;
+    if (!image->mSDLSurface)
+        return;
+
+    if (scaledHeight == 0 || scaledWidth == 0)
+        return;
+
+    Image *const tmpImage = image->SDLgetScaledImage(
+        scaledWidth, scaledHeight);
+    if (!tmpImage)
+        return;
+
+    const SDL_Rect &bounds = tmpImage->mBounds;
+    const int iw = bounds.w;
+    const int ih = bounds.h;
+    if (iw == 0 || ih == 0)
+        return;
+
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const int xOffset = top.xOffset + x;
+    const int yOffset = top.yOffset + y;
+    const int srcX = bounds.x;
+    const int srcY = bounds.y;
+
+    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        const int dstY = py + 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 dstX = px + xOffset;
+
+            SDL_Rect srcRect =
+            {
+                static_cast<int16_t>(srcX),
+                static_cast<int16_t>(srcY),
+                static_cast<uint16_t>(dw),
+                static_cast<uint16_t>(dh)
+            };
+
+            SDL_Rect dstRect =
+            {
+                static_cast<int16_t>(dstX),
+                static_cast<int16_t>(dstY),
+                0,
+                0
+            };
+
+            SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect,
+                            mSurface, &dstRect);
+        }
+    }
+
+    delete tmpImage;
+}
+
+void SDL2SoftwareGraphics::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 || !mSurface || !image || !image->mSDLSurface)
+        return;
+
+    const SDL_Rect &bounds = image->mBounds;
+    const int iw = bounds.w;
+    const int ih = bounds.h;
+    if (iw == 0 || ih == 0)
+        return;
+
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const int xOffset = top.xOffset + x;
+    const int yOffset = top.yOffset + y;
+    const int srcX = bounds.x;
+    const int srcY = bounds.y;
+
+    for (int py = 0; py < h; py += ih)  // Y position on pattern plane
+    {
+        const int dh = (py + ih >= h) ? h - py : ih;
+        const int dstY = py + 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 dstX = px + xOffset;
+
+            DoubleRect *const r = new DoubleRect();
+            SDL_Rect &srcRect = r->src;
+            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_Rect &dstRect = r->dst;
+            dstRect.x = static_cast<int16_t>(dstX);
+            dstRect.y = static_cast<int16_t>(dstY);
+
+            if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect,
+                mSurface, &dstRect) == 1)
+            {
+                vert->sdl.push_back(r);
+            }
+            else
+            {
+                delete r;
+            }
+        }
+    }
+}
+
+void SDL2SoftwareGraphics::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 SDL2SoftwareGraphics::calcTile(ImageVertexes *const vert,
+                                    const Image *const image,
+                                    int x, int y) const
+{
+    vert->image = image;
+    calcTileSDL(vert, x, y);
+}
+
+void SDL2SoftwareGraphics::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;
+    const gcn::ClipRectangle &top = mClipStack.top();
+    const SDL_Rect &bounds = image->mBounds;
+
+    DoubleRect *rect = new DoubleRect();
+    rect->src.x = static_cast<int16_t>(bounds.x);
+    rect->src.y = static_cast<int16_t>(bounds.y);
+    rect->src.w = static_cast<uint16_t>(bounds.w);
+    rect->src.h = static_cast<uint16_t>(bounds.h);
+    rect->dst.x = static_cast<int16_t>(x + top.xOffset);
+    rect->dst.y = static_cast<int16_t>(y + top.yOffset);
+    if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src,
+        mSurface, &rect->dst) == 1)
+    {
+        vert->sdl.push_back(rect);
+    }
+    else
+    {
+        delete rect;
+    }
+}
+
+void SDL2SoftwareGraphics::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 SDL2SoftwareGraphics::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,
+                mSurface, &(*it2)->dst);
+            ++ it2;
+        }
+    }
+}
+
+void SDL2SoftwareGraphics::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, mSurface, &(*it)->dst);
+        ++ it;
+    }
+}
+
+void SDL2SoftwareGraphics::updateScreen()
+{
+    BLOCK_START("Graphics::updateScreen")
+    SDL_UpdateWindowSurfaceRects(mWindow, &mRect, 1);
+    BLOCK_END("Graphics::updateScreen")
+}
+
+SDL_Surface *SDL2SoftwareGraphics::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 = MSDL_CreateRGBSurface(SDL_SWSURFACE,
+        mRect.w, mRect.h, 24, rmask, gmask, bmask, amask);
+
+    if (screenshot)
+        SDL_BlitSurface(mSurface, nullptr, screenshot, nullptr);
+
+    return screenshot;
+}
+
+bool SDL2SoftwareGraphics::drawNet(const int x1, const int y1,
+                                   const int x2, const int y2,
+                                   const int width, const int height)
+{
+    // +++ need use SDL_RenderDrawLines
+    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 SDL2SoftwareGraphics::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;
+    }
+
+    const Image *const *const grid = &imgRect.grid[0];
+    return calcImageRect(vert, x, y, w, h,
+        grid[0], grid[2], grid[6], grid[8],
+        grid[1], grid[5], grid[7], grid[3],
+        grid[4]);
+}
+
+int SDL2SoftwareGraphics::SDL_FakeUpperBlit(const SDL_Surface *const src,
+                                            SDL_Rect *const srcrect,
+                                            const SDL_Surface *const dst,
+                                            SDL_Rect *dstrect) const
+{
+    int srcx, srcy, w, h;
+
+    // Make sure the surfaces aren't locked
+    if (!src || !dst)
+        return -1;
+
+    if (!srcrect || !dstrect)
+        return -1;
+
+    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;
+
+    const SDL_Rect *const clip = &dst->clip_rect;
+    const int clipX = clip->x;
+    const int clipY = clip->y;
+    int dx = clipX - dstrect->x;
+    if (dx > 0)
+    {
+        w -= dx;
+        dstrect->x += static_cast<int16_t>(dx);
+        srcx += dx;
+    }
+    dx = dstrect->x + w - clipX - clip->w;
+    if (dx > 0)
+        w -= dx;
+
+    int dy = clipY - dstrect->y;
+    if (dy > 0)
+    {
+        h -= dy;
+        dstrect->y += static_cast<int16_t>(dy);
+        srcy += dy;
+    }
+    dy = dstrect->y + h - clipY - 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 SDL2SoftwareGraphics::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(mSurface);
+
+        const int bpp = mSurface->format->BytesPerPixel;
+        const uint32_t pixel = SDL_MapRGB(mSurface->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 *>(mSurface->pixels)
+                        + y * mSurface->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 *>(mSurface->pixels)
+                        + y * mSurface->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), mSurface->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 *>(mSurface->pixels)
+                        + y * mSurface->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 *const p0 = static_cast<uint8_t *>(mSurface->pixels)
+                        + y * mSurface->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 = mSurface->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*>(mSurface->pixels)
+                        + y * mSurface->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(mSurface);
+    }
+    else
+    {
+        SDL_Rect rect =
+        {
+            static_cast<int16_t>(area.x),
+            static_cast<int16_t>(area.y),
+            static_cast<uint16_t>(area.width),
+            static_cast<uint16_t>(area.height)
+        };
+
+        const uint32_t color = SDL_MapRGBA(mSurface->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(mSurface, &rect, color);
+    }
+}
+
+void SDL2SoftwareGraphics::_beginDraw()
+{
+    pushClipArea(gcn::Rectangle(0, 0, mRect.w, mRect.h));
+}
+
+void SDL2SoftwareGraphics::_endDraw()
+{
+    popClipArea();
+}
+
+bool SDL2SoftwareGraphics::pushClipArea(gcn::Rectangle area)
+{
+    const bool result = gcn::Graphics::pushClipArea(area);
+
+    const gcn::ClipRectangle &carea = mClipStack.top();
+    const SDL_Rect rect =
+    {
+        static_cast<int32_t>(carea.x),
+        static_cast<int32_t>(carea.y),
+        static_cast<int32_t>(carea.width),
+        static_cast<int32_t>(carea.height)
+    };
+    SDL_SetClipRect(mSurface, &rect);
+    return result;
+}
+
+void SDL2SoftwareGraphics::popClipArea()
+{
+    gcn::Graphics::popClipArea();
+
+    if (mClipStack.empty())
+        return;
+
+    const gcn::ClipRectangle &carea = mClipStack.top();
+    const SDL_Rect rect =
+    {
+        static_cast<int32_t>(carea.x),
+        static_cast<int32_t>(carea.y),
+        static_cast<int32_t>(carea.width),
+        static_cast<int32_t>(carea.height)
+    };
+
+    SDL_SetClipRect(mSurface, &rect);
+}
+
+void SDL2SoftwareGraphics::drawPoint(int x, int y)
+{
+    if (mClipStack.empty())
+        return;
+
+    const gcn::ClipRectangle& top = mClipStack.top();
+
+    x += top.xOffset;
+    y += top.yOffset;
+
+    if (!top.isPointInRect(x, y))
+        return;
+
+    if (mAlpha)
+        SDLputPixelAlpha(mSurface, x, y, mColor);
+    else
+        SDLputPixel(mSurface, x, y, mColor);
+}
+
+void SDL2SoftwareGraphics::drawHLine(int x1, int y, int x2)
+{
+    if (mClipStack.empty())
+        return;
+
+    const gcn::ClipRectangle& top = mClipStack.top();
+
+    const int xOffset = top.xOffset;
+    x1 += xOffset;
+    y += top.yOffset;
+    x2 += xOffset;
+
+    const int topY = top.y;
+    if (y < topY || y >= topY + top.height)
+        return;
+
+    if (x1 > x2)
+    {
+        x1 ^= x2;
+        x2 ^= x1;
+        x1 ^= x2;
+    }
+
+    const int topX = top.x;
+    if (topX > x1)
+    {
+        if (topX > x2)
+            return;
+
+        x1 = topX;
+    }
+
+    const int sumX = topX + top.width;
+    if (sumX <= x2)
+    {
+        if (sumX <= x1)
+            return;
+
+        x2 = sumX -1;
+    }
+
+    const int bpp = mSurface->format->BytesPerPixel;
+
+    SDL_LockSurface(mSurface);
+
+    uint8_t *p = static_cast<uint8_t*>(mSurface->pixels)
+        + y * mSurface->pitch + x1 * bpp;
+
+    const uint32_t pixel = SDL_MapRGB(mSurface->format,
+        static_cast<uint8_t>(mColor.r),
+        static_cast<uint8_t>(mColor.g),
+        static_cast<uint8_t>(mColor.b));
+    switch (bpp)
+    {
+        case 1:
+            for (; x1 <= x2; ++x1)
+                *(p++) = static_cast<uint8_t>(pixel);
+            break;
+
+        case 2:
+        {
+            uint16_t* q = reinterpret_cast<uint16_t*>(p);
+            for (; x1 <= x2; ++x1)
+                *(q++) = pixel;
+            break;
+        }
+
+        case 3:
+        {
+            const uint8_t b0 = static_cast<uint8_t>((pixel >> 16) & 0xff);
+            const uint8_t b1 = static_cast<uint8_t>((pixel >> 8) & 0xff);
+            const uint8_t b2 = static_cast<uint8_t>(pixel & 0xff);
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+            for (; x1 <= x2; ++x1)
+            {
+                p[0] = b0;
+                p[1] = b1;
+                p[2] = b2;
+                p += 3;
+            }
+#else
+            for (; x1 <= x2; ++x1)
+            {
+                p[0] = b2;
+                p[1] = b1;
+                p[2] = b0;
+                p += 3;
+            }
+#endif
+            break;
+        }
+
+        case 4:
+        {
+            uint32_t *q = reinterpret_cast<uint32_t*>(p);
+            if (mAlpha)
+            {
+                unsigned char a = static_cast<unsigned char>(mColor.a);
+                unsigned char a1 = 255 - a;
+                const int b0 = (pixel & 0xff) * a;
+                const int g0 = (pixel & 0xff00) * a;
+                const int r0 = (pixel & 0xff0000) * a;
+                for (; x1 <= x2; ++x1)
+                {
+                    const unsigned int b = (b0 + (*q & 0xff) * a1) >> 8;
+                    const unsigned int g = (g0 + (*q & 0xff00) * a1) >> 8;
+                    const unsigned int r = (r0 + (*q & 0xff0000) * a1) >> 8;
+                    *q = (b & 0xff) | (g & 0xff00) | (r & 0xff0000);
+
+                    q++;
+                }
+            }
+            else
+            {
+                for (; x1 <= x2; ++x1)
+                    *(q++) = pixel;
+            }
+            break;
+        }
+        default:
+            break;
+    }  // end switch
+
+    SDL_UnlockSurface(mSurface);
+}
+
+void SDL2SoftwareGraphics::drawVLine(int x, int y1, int y2)
+{
+    if (mClipStack.empty())
+        return;
+
+    const gcn::ClipRectangle& top = mClipStack.top();
+
+    const int yOffset = top.yOffset;
+    x += top.xOffset;
+    y1 += yOffset;
+    y2 += yOffset;
+
+    if (x < top.x || x >= top.x + top.width)
+        return;
+
+    if (y1 > y2)
+    {
+        y1 ^= y2;
+        y2 ^= y1;
+        y1 ^= y2;
+    }
+
+    if (top.y > y1)
+    {
+        if (top.y > y2)
+            return;
+
+        y1 = top.y;
+    }
+
+    const int sumY = top.y + top.height;
+    if (sumY <= y2)
+    {
+        if (sumY <= y1)
+            return;
+
+        y2 = sumY - 1;
+    }
+
+    const int bpp = mSurface->format->BytesPerPixel;
+
+    SDL_LockSurface(mSurface);
+
+    uint8_t *p = static_cast<uint8_t*>(mSurface->pixels)
+        + y1 * mSurface->pitch + x * bpp;
+
+    const uint32_t pixel = SDL_MapRGB(mSurface->format,
+        static_cast<uint8_t>(mColor.r),
+        static_cast<uint8_t>(mColor.g),
+        static_cast<uint8_t>(mColor.b));
+
+    const int pitch = mSurface->pitch;
+    switch (bpp)
+    {
+        case 1:
+            for (; y1 <= y2; ++y1)
+            {
+                *p = static_cast<uint8_t>(pixel);
+                p += pitch;
+            }
+            break;
+
+        case 2:
+            for (; y1 <= y2; ++ y1)
+            {
+                *reinterpret_cast<uint16_t*>(p)
+                    = static_cast<uint16_t>(pixel);
+                p += pitch;
+            }
+            break;
+
+        case 3:
+        {
+            const uint8_t b0 = static_cast<uint8_t>((pixel >> 16) & 0xff);
+            const uint8_t b1 = static_cast<uint8_t>((pixel >> 8) & 0xff);
+            const uint8_t b2 = static_cast<uint8_t>(pixel & 0xff);
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+            for (; y1 <= y2; ++y1)
+            {
+                p[0] = b0;
+                p[1] = b1;
+                p[2] = b2;
+                p += pitch;
+            }
+#else
+            for (; y1 <= y2; ++y1)
+            {
+                p[0] = b2;
+                p[1] = b1;
+                p[2] = b0;
+                p += pitch;
+            }
+#endif
+            break;
+        }
+
+        case 4:
+        {
+            if (mAlpha)
+            {
+                unsigned char a = static_cast<unsigned char>(mColor.a);
+                unsigned char a1 = 255 - a;
+                const int b0 = (pixel & 0xff) * a;
+                const int g0 = (pixel & 0xff00) * a;
+                const int r0 = (pixel & 0xff0000) * a;
+                for (; y1 <= y2; ++y1)
+                {
+                    const unsigned int dst = *reinterpret_cast<uint32_t*>(p);
+                    const unsigned int b = (b0 + (dst & 0xff) * a1) >> 8;
+                    const unsigned int g = (g0 + (dst & 0xff00) * a1) >> 8;
+                    const unsigned int r = (r0 + (dst & 0xff0000) * a1) >> 8;
+                    *reinterpret_cast<uint32_t*>(p) =
+                        (b & 0xff) | (g & 0xff00) | (r & 0xff0000);
+
+                    p += pitch;
+                }
+            }
+            else
+            {
+                for (; y1 <= y2; ++y1)
+                {
+                    *reinterpret_cast<uint32_t*>(p) = pixel;
+                    p += pitch;
+                }
+            }
+            break;
+        }
+
+        default:
+            break;
+    }  // end switch
+
+    SDL_UnlockSurface(mSurface);
+}
+
+void SDL2SoftwareGraphics::drawRectangle(const gcn::Rectangle &rectangle)
+{
+    const int x1 = rectangle.x;
+    const int x2 = x1 + rectangle.width - 1;
+    const int y1 = rectangle.y;
+    const int y2 = y1 + rectangle.height - 1;
+
+    drawHLine(x1, y1, x2);
+    drawHLine(x1, y2, x2);
+
+    drawVLine(x1, y1, y2);
+    drawVLine(x2, y1, y2);
+}
+
+void SDL2SoftwareGraphics::drawLine(int x1, int y1, int x2, int y2)
+{
+    if (x1 == x2)
+    {
+        drawVLine(x1, y1, y2);
+        return;
+    }
+    if (y1 == y2)
+    {
+        drawHLine(x1, y1, x2);
+        return;
+    }
+}
+
+bool SDL2SoftwareGraphics::setVideoMode(const int w, const int h,
+                                        const int bpp, const bool fs,
+                                        const bool hwaccel, const bool resize,
+                                        const bool noFrame)
+{
+    setMainFlags(w, h, bpp, fs, hwaccel, resize, noFrame);
+
+    if (!(mWindow = graphicsManager.createWindow(w, h, bpp,
+        getSoftwareFlags())))
+    {
+        mRect.w = 0;
+        mRect.h = 0;
+        mSurface = nullptr;
+        return false;
+    }
+
+    mSurface = SDL_GetWindowSurface(mWindow);
+    logger->log("window surface: %p", mSurface);
+
+    int w1 = 0;
+    int h1 = 0;
+    SDL_GetWindowSize(mWindow, &w1, &h1);
+    mRect.w = w1;
+    mRect.h = h1;
+
+    mRenderer = graphicsManager.createRenderer(mWindow, mRendererFlags);
+    SDLImageHelper::setRenderer(mRenderer);
+    return videoInfo();
+}
+
+#endif  // USE_SDL2
diff --git a/src/render/sdl2softwaregraphics.h b/src/render/sdl2softwaregraphics.h
new file mode 100644
index 000000000..7ddba5018
--- /dev/null
+++ b/src/render/sdl2softwaregraphics.h
@@ -0,0 +1,157 @@
+/*
+ *  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 SDL2SOFTWAREGRAPHICS_H
+#define SDL2SOFTWAREGRAPHICS_H
+
+#ifdef USE_SDL2
+
+#include "render/graphics.h"
+
+#include "localconsts.h"
+
+class Image;
+class ImageCollection;
+class ImageVertexes;
+class MapLayer;
+
+struct SDL_Surface;
+
+/**
+ * A central point of control for graphics.
+ */
+class SDL2SoftwareGraphics : public Graphics
+{
+    public:
+        /**
+         * Constructor.
+         */
+        SDL2SoftwareGraphics();
+
+        A_DELETE_COPY(SDL2SoftwareGraphics)
+
+        /**
+         * Destructor.
+         */
+        virtual ~SDL2SoftwareGraphics();
+
+        void _beginDraw();
+
+        void _endDraw();
+
+        bool pushClipArea(gcn::Rectangle rect);
+
+        void popClipArea();
+
+        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 fillRectangle(const gcn::Rectangle &rect) override;
+
+        void drawRectangle(const gcn::Rectangle &rect) override;
+
+        void drawPoint(int x, int y) override;
+
+        void drawLine(int x1, int y1, int x2, int y2) override;
+
+        bool setVideoMode(const int w, const int h, const int bpp,
+                          const bool fs, const bool hwaccel,
+                          const bool resize, const bool noFrame);
+
+        void setRendererFlags(const uint32_t flags)
+        { mRendererFlags = flags; }
+
+    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;
+
+        void drawHLine(int x1, int y, int x2);
+
+        void drawVLine(int x, int y1, int y2);
+
+        uint32_t mRendererFlags;
+        SDL_Surface *mSurface;
+        uint32_t mOldPixel;
+        int mOldAlpha;
+};
+
+#endif  // USE_SDL2
+#endif  // SDL2SOFTWAREGRAPHICS_H
diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index c289c90cd..1a327eae1 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -42,9 +42,7 @@
 #include "utils/sdlcheckutils.h"
 
 #include <SDL_image.h>
-#ifndef USE_SDL2
 #include <SDL_rotozoom.h>
-#endif
 
 #include "debug.h"
 
@@ -388,7 +386,6 @@ Image* Image::SDLgetScaledImage(const int width, const int height) const
 
     Image* scaledImage = nullptr;
 
-#ifndef USE_SDL2
     if (mSDLSurface)
     {
         SDL_Surface *const scaledSurface = zoomSurface(mSDLSurface,
@@ -404,7 +401,6 @@ Image* Image::SDLgetScaledImage(const int width, const int height) const
             MSDL_FreeSurface(scaledSurface);
         }
     }
-#endif
     return scaledImage;
 }
 
@@ -423,7 +419,11 @@ Image *Image::getSubImage(const int x, const int y,
 #endif
 
 #ifdef USE_SDL2
-    return new SubImage(this, mTexture, x, y, width, height);
+    // +++ probably default sdl render is broken here
+    if (mode == RENDER_SOFTWARE)
+        return new SubImage(this, mSDLSurface, x, y, width, height);
+    else
+        return new SubImage(this, mTexture, x, y, width, height);
 #else
     return new SubImage(this, mSDLSurface, x, y, width, height);
 #endif
diff --git a/src/resources/image.h b/src/resources/image.h
index 7cdb1b5b3..664642e3a 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -61,6 +61,8 @@ class Image : public Resource
     friend class SDLImageHelper;
     friend class SurfaceGraphics;
 #ifdef USE_SDL2
+    friend class SDL2SoftwareGraphics;
+    friend class SDL2SoftwareImageHelper;
     friend class SurfaceImageHelper;
 #endif
     friend class TestLauncher;
diff --git a/src/resources/sdl2softwareimagehelper.cpp b/src/resources/sdl2softwareimagehelper.cpp
new file mode 100644
index 000000000..3511b8298
--- /dev/null
+++ b/src/resources/sdl2softwareimagehelper.cpp
@@ -0,0 +1,184 @@
+/*
+ *  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/>.
+ */
+
+#ifdef USE_SDL2
+
+#include "resources/sdl2softwareimagehelper.h"
+
+#include "resources/dye.h"
+#include "resources/resourcemanager.h"
+
+#include "client.h"
+#include "logger.h"
+#include "main.h"
+
+#include "resources/image.h"
+
+#include "utils/sdlcheckutils.h"
+
+#include <SDL_image.h>
+
+#include "debug.h"
+
+bool SDL2SoftwareImageHelper::mEnableAlphaCache = false;
+SDL_Renderer *SDL2SoftwareImageHelper::mRenderer = nullptr;
+
+Image *SDL2SoftwareImageHelper::load(SDL_RWops *const rw, Dye const &dye) const
+{
+    SDL_Surface *const tmpImage = loadPng(rw);
+    if (!tmpImage)
+    {
+        logger->log("Error, image load failed: %s", IMG_GetError());
+        return nullptr;
+    }
+
+    SDL_PixelFormat rgba;
+    rgba.palette = nullptr;
+    rgba.BitsPerPixel = 32;
+    rgba.BytesPerPixel = 4;
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    rgba.Rmask = 0x000000FF;
+    rgba.Gmask = 0x0000FF00;
+    rgba.Bmask = 0x00FF0000;
+    rgba.Amask = 0xFF000000;
+#else
+    rgba.Rmask = 0xFF000000;
+    rgba.Gmask = 0x00FF0000;
+    rgba.Bmask = 0x0000FF00;
+    rgba.Amask = 0x000000FF;
+#endif
+
+    SDL_Surface *const surf = MSDL_ConvertSurface(
+        tmpImage, &rgba, SDL_SWSURFACE);
+    MSDL_FreeSurface(tmpImage);
+
+    uint32_t *pixels = static_cast<uint32_t *>(surf->pixels);
+    const int type = dye.getType();
+
+    switch (type)
+    {
+        case 1:
+        {
+            const DyePalette *const pal = dye.getSPalete();
+            if (pal)
+                pal->replaceSColor(pixels, surf->w * surf->h);
+            break;
+        }
+        case 2:
+        {
+            const DyePalette *const pal = dye.getAPalete();
+            if (pal)
+                pal->replaceAColor(pixels, surf->w * surf->h);
+            break;
+        }
+        case 0:
+        default:
+        {
+            dye.normalDye(pixels, surf->w * surf->h);
+            break;
+        }
+    }
+
+    Image *const image = load(surf);
+    MSDL_FreeSurface(surf);
+    return image;
+}
+
+Image *SDL2SoftwareImageHelper::load(SDL_Surface *const tmpImage) const
+{
+    return _SDLload(tmpImage);
+}
+
+Image *SDL2SoftwareImageHelper::createTextSurface(SDL_Surface *const tmpImage,
+                                                  const int width A_UNUSED,
+                                                  const int height A_UNUSED,
+                                                  const float alpha) const
+{
+    if (!tmpImage)
+        return nullptr;
+
+    Image *const img = _SDLload(tmpImage);
+    if (img)
+        img->setAlpha(alpha);
+    return img;
+}
+
+SDL_Surface* SDL2SoftwareImageHelper::SDLDuplicateSurface(SDL_Surface *const
+                                                          tmpImage)
+{
+    if (!tmpImage || !tmpImage->format)
+        return nullptr;
+
+    return MSDL_ConvertSurface(tmpImage, tmpImage->format, SDL_SWSURFACE);
+}
+
+Image *SDL2SoftwareImageHelper::_SDLload(SDL_Surface *tmpImage) const
+{
+    if (!tmpImage)
+        return nullptr;
+
+//    SDL_Texture *const texture = SDL_CreateTextureFromSurface(
+//        mRenderer, tmpImage);
+//    if (!texture)
+//        return nullptr;
+//    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+//    return new Image(texture, tmpImage->w, tmpImage->h);
+    SDL_Surface *image = convertTo32Bit(tmpImage);
+    return new Image(image, false, nullptr);
+}
+
+RenderType SDL2SoftwareImageHelper::useOpenGL() const
+{
+    return RENDER_SOFTWARE;
+}
+
+SDL_Surface *SDL2SoftwareImageHelper::create32BitSurface(int width,
+                                                         int height) const
+{
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    const int rmask = 0xff000000;
+    const int gmask = 0x00ff0000;
+    const int bmask = 0x0000ff00;
+    const int amask = 0x000000ff;
+#else
+    const int rmask = 0x000000ff;
+    const int gmask = 0x0000ff00;
+    const int bmask = 0x00ff0000;
+    const int amask = 0xff000000;
+#endif
+
+    return MSDL_CreateRGBSurface(SDL_SWSURFACE,
+        width, height, 32, rmask, gmask, bmask, amask);
+}
+
+int SDL2SoftwareImageHelper::combineSurface(SDL_Surface *const src,
+                                            SDL_Rect *const srcrect,
+                                            SDL_Surface *const dst,
+                                            SDL_Rect *const dstrect)
+{
+    SDL_SetSurfaceBlendMode(src, SDL_BLENDMODE_BLEND);
+    SDL_BlitSurface(src, srcrect, dst, dstrect);
+    return 1;
+}
+
+#endif  // USE_SDL2
diff --git a/src/resources/sdl2softwareimagehelper.h b/src/resources/sdl2softwareimagehelper.h
new file mode 100644
index 000000000..877ae9032
--- /dev/null
+++ b/src/resources/sdl2softwareimagehelper.h
@@ -0,0 +1,113 @@
+/*
+ *  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 RESOURCES_SDL2SOFTWAREIMAGEHELPER_H
+#define RESOURCES_SDL2SOFTWAREIMAGEHELPER_H
+
+#ifdef USE_SDL2
+
+#include "localconsts.h"
+
+#include "resources/imagehelper.h"
+
+#include <SDL.h>
+
+class Dye;
+class Image;
+
+/**
+ * Defines a class for loading and storing images.
+ */
+class SDL2SoftwareImageHelper final : public ImageHelper
+{
+    friend class Image;
+
+    public:
+        SDL2SoftwareImageHelper()
+        { }
+
+        A_DELETE_COPY(SDL2SoftwareImageHelper)
+
+        virtual ~SDL2SoftwareImageHelper()
+        { }
+
+        /**
+         * Loads an image from an SDL_RWops structure and recolors it.
+         *
+         * @param rw         The SDL_RWops to load the image from.
+         * @param dye        The dye used to recolor the image.
+         *
+         * @return <code>NULL</code> if an error occurred, a valid pointer
+         *         otherwise.
+         */
+        Image *load(SDL_RWops *const rw,
+                    Dye const &dye) const override A_WARN_UNUSED;
+
+        /**
+         * Loads an image from an SDL surface.
+         */
+        Image *load(SDL_Surface *const tmpImage) const override A_WARN_UNUSED;
+
+        Image *createTextSurface(SDL_Surface *const tmpImage,
+                                 const int width, const int height,
+                                 const float alpha)
+                                 const override A_WARN_UNUSED;
+
+        static void SDLSetEnableAlphaCache(const bool n)
+        { mEnableAlphaCache = n; }
+
+        static bool SDLGetEnableAlphaCache() A_WARN_UNUSED
+        { return mEnableAlphaCache; }
+
+         /**
+         * Tells if the image was loaded using OpenGL or SDL
+         * @return true if OpenGL, false if SDL.
+         */
+        RenderType useOpenGL() const override A_WARN_UNUSED;
+
+        static SDL_Surface* SDLDuplicateSurface(SDL_Surface *const tmpImage)
+                                                A_WARN_UNUSED;
+
+        SDL_Surface *create32BitSurface(int width, int height) const override;
+
+        static int combineSurface(SDL_Surface *const src,
+                                  SDL_Rect *const srcrect,
+                                  SDL_Surface *const dst,
+                                  SDL_Rect *const dstrect);
+
+#ifdef USE_SDL2
+        static void setRenderer(SDL_Renderer *const renderer)
+        { mRenderer = renderer; }
+#endif
+
+    protected:
+        /** SDL_Surface to SDL_Surface Image loader */
+        Image *_SDLload(SDL_Surface *tmpImage) const A_WARN_UNUSED;
+
+        static bool mEnableAlphaCache;
+#ifdef USE_SDL2
+        static SDL_Renderer *mRenderer;
+#endif
+};
+
+#endif  // USE_SDL2
+#endif  // RESOURCES_SDL2SOFTWAREIMAGEHELPER_H