Move static methods from Image class to ImageHelper class.

Remove SDL merge method. It was very slow and unused.

6 files changed, 767 insertions, 740 deletions

diff --git a/src/resources/ambientlayer.cpp b/src/resources/ambientlayer.cpp
index b5640904c..f2eaeab81 100644
--- a/src/resources/ambientlayer.cpp
+++ b/src/resources/ambientlayer.cpp
@@ -24,6 +24,7 @@
 #include "graphics.h"
 
 #include "resources/image.h"
+#include "resources/imagehelper.h"
 #include "resources/resourcemanager.h"
 
 #include "debug.h"
@@ -38,7 +39,7 @@ AmbientLayer::AmbientLayer(Image *img, float parallax,
     if (!mImage)
         return;
 
-    if (keepRatio && !mImage->useOpenGL()
+    if (keepRatio && !ImageHelper::useOpenGL()
         /*&& defaultScreenWidth != 0
         && defaultScreenHeight != 0*/
         && mainGraphics->mWidth != defaultScreenWidth
@@ -105,7 +106,7 @@ void AmbientLayer::draw(Graphics *graphics, int x, int y)
     if (!mImage)
         return;
 
-    if (!mImage->useOpenGL() || !mKeepRatio)
+    if (!ImageHelper::useOpenGL() || !mKeepRatio)
     {
         graphics->drawImagePattern(mImage, static_cast<int>(-mPosX),
                 static_cast<int>(-mPosY), x + static_cast<int>(mPosX),
diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index 85643c8df..0e0937ce6 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -36,21 +36,13 @@
 
 #include "utils/stringutils.h"
 
+#include "resources/imagehelper.h"
+
 #include <SDL_image.h>
 #include <SDL_rotozoom.h>
 
 #include "debug.h"
 
-#ifdef USE_OPENGL
-int Image::mUseOpenGL = 0;
-int Image::mTextureType = 0;
-int Image::mInternalTextureType = GL_RGBA8;
-int Image::mTextureSize = 0;
-bool Image::mBlur = true;
-#endif
-bool Image::mEnableAlphaCache = false;
-bool Image::mEnableAlpha = true;
-
 Image::Image(SDL_Surface *image, bool hasAlphaChannel0, Uint8 *alphaChannel):
     mAlpha(1.0f),
     mHasAlphaChannel(hasAlphaChannel0),
@@ -63,7 +55,7 @@ Image::Image(SDL_Surface *image, bool hasAlphaChannel0, Uint8 *alphaChannel):
     mGLImage = 0;
 #endif
 
-    mUseAlphaCache = Image::mEnableAlphaCache;
+    mUseAlphaCache = ImageHelper::mEnableAlphaCache;
 
     mBounds.x = 0;
     mBounds.y = 0;
@@ -123,214 +115,6 @@ Image::~Image()
     unload();
 }
 
-Resource *Image::load(SDL_RWops *rw)
-{
-    SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
-
-    if (!tmpImage)
-    {
-        logger->log("Error, image load failed: %s", IMG_GetError());
-        return nullptr;
-    }
-
-    Image *image = load(tmpImage);
-
-    SDL_FreeSurface(tmpImage);
-    return image;
-}
-
-Resource *Image::load(SDL_RWops *rw, Dye const &dye)
-{
-    SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
-
-    if (!tmpImage)
-    {
-        logger->log("Error, image load failed: %s", IMG_GetError());
-        return nullptr;
-    }
-
-    SDL_Surface *surf = nullptr;
-    SDL_PixelFormat rgba;
-    rgba.palette = nullptr;
-    rgba.BitsPerPixel = 32;
-    rgba.BytesPerPixel = 4;
-    rgba.colorkey = 0;
-    rgba.alpha = 255;
-    if (mUseOpenGL)
-    {
-        surf = convertTo32Bit(tmpImage);
-        SDL_FreeSurface(tmpImage);
-
-        Uint32 *pixels = static_cast<Uint32 *>(surf->pixels);
-        DyePalette *pal = dye.getSPalete();
-
-        if (pal)
-        {
-            for (Uint32 *p_end = pixels + surf->w * surf->h;
-                pixels != p_end; ++pixels)
-            {
-                Uint8 *p = (Uint8 *)pixels;
-                const int alpha = *p & 255;
-                if (!alpha)
-                    continue;
-                pal->replaceOGLColor(p);
-            }
-        }
-        else
-        {
-            for (Uint32 *p_end = pixels + surf->w * surf->h;
-                pixels != p_end; ++pixels)
-            {
-                const Uint32 p = *pixels;
-                const int alpha = (p >> 24) & 255;
-                if (!alpha)
-                    continue;
-                int v[3];
-                v[0] = (p) & 255;
-                v[1] = (p >> 8) & 255;
-                v[2] = (p >> 16 ) & 255;
-                dye.update(v);
-                *pixels = (v[0]) | (v[1] << 8) | (v[2] << 16) | (alpha << 24);
-            }
-        }
-    }
-    else
-    {
-        rgba.Rmask = 0xFF000000; rgba.Rloss = 0; rgba.Rshift = 24;
-        rgba.Gmask = 0x00FF0000; rgba.Gloss = 0; rgba.Gshift = 16;
-        rgba.Bmask = 0x0000FF00; rgba.Bloss = 0; rgba.Bshift = 8;
-        rgba.Amask = 0x000000FF; rgba.Aloss = 0; rgba.Ashift = 0;
-
-        surf = SDL_ConvertSurface(tmpImage, &rgba, SDL_SWSURFACE);
-        SDL_FreeSurface(tmpImage);
-
-        Uint32 *pixels = static_cast<Uint32 *>(surf->pixels);
-        DyePalette *pal = dye.getSPalete();
-
-        if (pal)
-        {
-            for (Uint32 *p_end = pixels + surf->w * surf->h;
-                pixels != p_end; ++pixels)
-            {
-                Uint8 *p = (Uint8 *)pixels;
-                const int alpha = *p & 255;
-                if (!alpha)
-                    continue;
-                pal->replaceColor(p + 1);
-            }
-        }
-        else
-        {
-            for (Uint32 *p_end = pixels + surf->w * surf->h;
-                pixels != p_end; ++pixels)
-            {
-                const Uint32 p = *pixels;
-                const int alpha = p & 255;
-                if (!alpha)
-                    continue;
-                int v[3];
-                v[0] = (p >> 24) & 255;
-                v[1] = (p >> 16) & 255;
-                v[2] = (p >> 8 ) & 255;
-                dye.update(v);
-                *pixels = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | alpha;
-            }
-        }
-    }
-
-    Image *image = load(surf);
-    SDL_FreeSurface(surf);
-    return image;
-}
-
-Image *Image::load(SDL_Surface *tmpImage)
-{
-#ifdef USE_OPENGL
-    if (mUseOpenGL)
-        return _GLload(tmpImage);
-#endif
-    return _SDLload(tmpImage);
-}
-
-Image *Image::createTextSurface(SDL_Surface *tmpImage, float alpha)
-{
-    if (!tmpImage)
-        return nullptr;
-
-    Image *img;
-#ifdef USE_OPENGL
-    if (mUseOpenGL)
-    {
-        img = _GLload(tmpImage);
-        if (img)
-            img->setAlpha(alpha);
-        return img;
-    }
-#endif
-
-    bool hasAlpha = false;
-    bool converted = false;
-
-    const int sz = tmpImage->w * tmpImage->h;
-
-    // The alpha channel to be filled with alpha values
-    Uint8 *alphaChannel = new Uint8[sz];
-
-    const SDL_PixelFormat * const fmt = tmpImage->format;
-    if (fmt->Amask)
-    {
-        for (int i = 0; i < sz; ++ i)
-        {
-            Uint32 c = (static_cast<Uint32*>(tmpImage->pixels))[i];
-
-            unsigned v = (c & fmt->Amask) >> fmt->Ashift;
-            Uint8 a = (v << fmt->Aloss) + (v >> (8 - (fmt->Aloss << 1)));
-
-            Uint8 a2 = static_cast<Uint8>(static_cast<float>(a) * alpha);
-
-            c &= ~fmt->Amask;
-            c |= ((a2 >> fmt->Aloss) << fmt->Ashift & fmt->Amask);
-            (static_cast<Uint32*>(tmpImage->pixels))[i] = c;
-
-            if (a != 255)
-                hasAlpha = true;
-
-            alphaChannel[i] = a;
-        }
-    }
-
-    SDL_Surface *image;
-
-    // Convert the surface to the current display format
-    if (hasAlpha)
-    {
-        image = SDL_DisplayFormatAlpha(tmpImage);
-    }
-    else
-    {
-        image = SDL_DisplayFormat(tmpImage);
-
-        // We also delete the alpha channel since
-        // it's not used.
-        delete [] alphaChannel;
-        alphaChannel = nullptr;
-    }
-
-    if (!image)
-    {
-        logger->log1("Error: Image convert failed.");
-        delete [] alphaChannel;
-        return nullptr;
-    }
-
-    if (converted)
-        SDL_FreeSurface(tmpImage);
-
-    img = new Image(image, hasAlpha, alphaChannel);
-    img->mAlpha = alpha;
-    return img;
-}
-
 void Image::SDLCleanCache()
 {
     ResourceManager *resman = ResourceManager::getInstance();
@@ -374,22 +158,13 @@ void Image::unload()
 #endif
 }
 
-int Image::useOpenGL() const
-{
-#ifdef USE_OPENGL
-    return mUseOpenGL;
-#else
-    return 0;
-#endif
-}
-
 bool Image::hasAlphaChannel()
 {
     if (mLoaded)
         return mHasAlphaChannel;
 
 #ifdef USE_OPENGL
-    if (mUseOpenGL)
+    if (ImageHelper::mUseOpenGL)
         return true;
 #endif
 
@@ -406,7 +181,7 @@ SDL_Surface *Image::getByAlpha(float alpha)
 
 void Image::setAlpha(float alpha)
 {
-    if (mAlpha == alpha || !mEnableAlpha)
+    if (mAlpha == alpha || !ImageHelper::mEnableAlpha)
         return;
 
     if (alpha < 0.0f || alpha > 1.0f)
@@ -456,7 +231,7 @@ void Image::setAlpha(float alpha)
             }
             else
             {
-                mSDLSurface = Image::SDLDuplicateSurface(mSDLSurface);
+                mSDLSurface = ImageHelper::SDLDuplicateSurface(mSDLSurface);
             }
     //        logger->log("miss");
         }
@@ -510,97 +285,6 @@ void Image::setAlpha(float alpha)
     }
 }
 
-Image* Image::SDLmerge(Image *image, int x, int y)
-{
-    if (!mSDLSurface || !image || !image->mSDLSurface)
-        return nullptr;
-
-    SDL_Surface* surface = new SDL_Surface(*(image->mSDLSurface));
-
-    Uint32 surface_pix, cur_pix;
-    Uint8 r, g, b, a, p_r, p_g, p_b, p_a;
-    double f_a, f_ca, f_pa;
-    SDL_PixelFormat *current_fmt = mSDLSurface->format;
-    SDL_PixelFormat *surface_fmt = surface->format;
-    int current_offset, surface_offset;
-    int offset_x, offset_y;
-
-    SDL_LockSurface(surface);
-    SDL_LockSurface(mSDLSurface);
-
-    const int x0 = (y * mBounds.w) + x;
-    const int maxX = std::min(image->mBounds.w,
-        static_cast<Uint16>(mBounds.w - x));
-    const int maxY = std::min(image->mBounds.w,
-        static_cast<Uint16>(mBounds.h - y));
-
-    // for each pixel lines of a source image
-    for (offset_x = ((x > 0) ? 0 : -x); offset_x < maxX; offset_x++)
-    {
-        const int x1 = x0 + offset_x;
-        for (offset_y = ((y > 0) ? 0 : -y); offset_y < maxY; offset_y++)
-        {
-            // Computing offset on both images
-            current_offset = (offset_y * mBounds.w) + x1;
-            surface_offset = offset_y * surface->w + offset_x;
-
-            // Retrieving a pixel to merge
-            surface_pix = (static_cast<Uint32*>(
-                surface->pixels))[surface_offset];
-            cur_pix = (static_cast<Uint32*>(
-                mSDLSurface->pixels))[current_offset];
-
-            // Retreiving each channel of the pixel using pixel format
-            r = static_cast<Uint8>(((surface_pix & surface_fmt->Rmask) >>
-                          surface_fmt->Rshift) << surface_fmt->Rloss);
-            g = static_cast<Uint8>(((surface_pix & surface_fmt->Gmask) >>
-                          surface_fmt->Gshift) << surface_fmt->Gloss);
-            b = static_cast<Uint8>(((surface_pix & surface_fmt->Bmask) >>
-                          surface_fmt->Bshift) << surface_fmt->Bloss);
-            a = static_cast<Uint8>(((surface_pix & surface_fmt->Amask) >>
-                          surface_fmt->Ashift) << surface_fmt->Aloss);
-
-            // Retreiving previous alpha value
-            p_a = static_cast<Uint8>(((cur_pix & current_fmt->Amask) >>
-                            current_fmt->Ashift) << current_fmt->Aloss);
-
-            // new pixel with no alpha or nothing on previous pixel
-            if (a == SDL_ALPHA_OPAQUE || (p_a == 0 && a > 0))
-            {
-                (static_cast<Uint32 *>(surface->pixels))[current_offset] =
-                    SDL_MapRGBA(current_fmt, r, g, b, a);
-            }
-            else if (a > 0)
-            { // alpha is lower => merge color with previous value
-                f_a = static_cast<double>(a) / 255.0;
-                f_ca = 1.0 - f_a;
-                f_pa = static_cast<double>(p_a) / 255.0;
-                p_r = static_cast<Uint8>(((cur_pix & current_fmt->Rmask) >>
-                                current_fmt->Rshift) << current_fmt->Rloss);
-                p_g = static_cast<Uint8>(((cur_pix & current_fmt->Gmask) >>
-                                current_fmt->Gshift) << current_fmt->Gloss);
-                p_b = static_cast<Uint8>(((cur_pix & current_fmt->Bmask) >>
-                                current_fmt->Bshift) << current_fmt->Bloss);
-                r = static_cast<Uint8>(static_cast<double>(p_r) * f_ca
-                    * f_pa + static_cast<double>(r) * f_a);
-                g = static_cast<Uint8>(static_cast<double>(p_g) * f_ca
-                    * f_pa + static_cast<double>(g) * f_a);
-                b = static_cast<Uint8>(static_cast<double>(p_b) * f_ca
-                    * f_pa + static_cast<double>(b) * f_a);
-                a = (a > p_a ? a : p_a);
-               (static_cast<Uint32 *>(surface->pixels))[current_offset] =
-                   SDL_MapRGBA(current_fmt, r, g, b, a);
-            }
-        }
-    }
-    SDL_UnlockSurface(surface);
-    SDL_UnlockSurface(mSDLSurface);
-
-    Image *newImage = new Image(surface);
-
-    return newImage;
-}
-
 Image* Image::SDLgetScaledImage(int width, int height)
 {
     // No scaling on incorrect new values.
@@ -625,312 +309,18 @@ Image* Image::SDLgetScaledImage(int width, int height)
         // and about freeing the given SDL_surface*.
         if (scaledSurface)
         {
-            scaledImage = load(scaledSurface);
+            scaledImage = ImageHelper::load(scaledSurface);
             SDL_FreeSurface(scaledSurface);
         }
     }
     return scaledImage;
 }
 
-SDL_Surface* Image::convertTo32Bit(SDL_Surface* tmpImage)
-{
-    if (!tmpImage)
-        return nullptr;
-    SDL_PixelFormat RGBAFormat;
-    RGBAFormat.palette = nullptr;
-    RGBAFormat.colorkey = 0;
-    RGBAFormat.alpha = 0;
-    RGBAFormat.BitsPerPixel = 32;
-    RGBAFormat.BytesPerPixel = 4;
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    RGBAFormat.Rmask = 0xFF000000;
-    RGBAFormat.Rshift = 0;
-    RGBAFormat.Rloss = 0;
-    RGBAFormat.Gmask = 0x00FF0000;
-    RGBAFormat.Gshift = 8;
-    RGBAFormat.Gloss = 0;
-    RGBAFormat.Bmask = 0x0000FF00;
-    RGBAFormat.Bshift = 16;
-    RGBAFormat.Bloss = 0;
-    RGBAFormat.Amask = 0x000000FF;
-    RGBAFormat.Ashift = 24;
-    RGBAFormat.Aloss = 0;
-#else
-    RGBAFormat.Rmask = 0x000000FF;
-    RGBAFormat.Rshift = 24;
-    RGBAFormat.Rloss = 0;
-    RGBAFormat.Gmask = 0x0000FF00;
-    RGBAFormat.Gshift = 16;
-    RGBAFormat.Gloss = 0;
-    RGBAFormat.Bmask = 0x00FF0000;
-    RGBAFormat.Bshift = 8;
-    RGBAFormat.Bloss = 0;
-    RGBAFormat.Amask = 0xFF000000;
-    RGBAFormat.Ashift = 0;
-    RGBAFormat.Aloss = 0;
-#endif
-    return SDL_ConvertSurface(tmpImage, &RGBAFormat, SDL_SWSURFACE);
-}
-
-SDL_Surface* Image::SDLDuplicateSurface(SDL_Surface* tmpImage)
-{
-    if (!tmpImage || !tmpImage->format)
-        return nullptr;
-
-    return SDL_ConvertSurface(tmpImage, tmpImage->format, SDL_SWSURFACE);
-}
-
-Image *Image::_SDLload(SDL_Surface *tmpImage)
-{
-    if (!tmpImage)
-        return nullptr;
-
-    bool hasAlpha = false;
-    bool converted = false;
-
-    if (tmpImage->format->BitsPerPixel != 32)
-    {
-        tmpImage = convertTo32Bit(tmpImage);
-
-        if (!tmpImage)
-            return nullptr;
-        converted = true;
-    }
-
-    const int sz = tmpImage->w * tmpImage->h;
-
-    // The alpha channel to be filled with alpha values
-    Uint8 *alphaChannel = new Uint8[sz];
-
-    // Figure out whether the image uses its alpha layer
-    if (!tmpImage->format->palette)
-    {
-        const SDL_PixelFormat * const fmt = tmpImage->format;
-        if (fmt->Amask)
-        {
-            for (int i = 0; i < sz; ++ i)
-            {
-                unsigned v = ((static_cast<Uint32*>(tmpImage->pixels))[i]
-                    & fmt->Amask) >> fmt->Ashift;
-                Uint8 a = (v << fmt->Aloss) + (v >> (8 - (fmt->Aloss << 1)));
-
-                if (a != 255)
-                    hasAlpha = true;
-
-                alphaChannel[i] = a;
-            }
-        }
-        else
-        {
-            if (SDL_ALPHA_OPAQUE != 255)
-            {
-                hasAlpha = true;
-                memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
-            }
-        }
-    }
-    else
-    {
-        if (SDL_ALPHA_OPAQUE != 255)
-        {
-            hasAlpha = true;
-            memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
-        }
-    }
-
-    SDL_Surface *image;
-
-    // Convert the surface to the current display format
-    if (hasAlpha)
-    {
-        image = SDL_DisplayFormatAlpha(tmpImage);
-    }
-    else
-    {
-        image = SDL_DisplayFormat(tmpImage);
-
-        // We also delete the alpha channel since
-        // it's not used.
-        delete [] alphaChannel;
-        alphaChannel = nullptr;
-    }
-
-    if (!image)
-    {
-        logger->log1("Error: Image convert failed.");
-        delete [] alphaChannel;
-        return nullptr;
-    }
-
-    if (converted)
-        SDL_FreeSurface(tmpImage);
-
-    return new Image(image, hasAlpha, alphaChannel);
-}
-
-#ifdef USE_OPENGL
-Image *Image::_GLload(SDL_Surface *tmpImage)
-{
-    if (!tmpImage)
-        return nullptr;
-
-    // Flush current error flag.
-    glGetError();
-
-    int width = tmpImage->w;
-    int height = tmpImage->h;
-    int realWidth = powerOfTwo(width);
-    int realHeight = powerOfTwo(height);
-
-    if (realWidth < width || realHeight < height)
-    {
-        logger->log("Warning: image too large, cropping to %dx%d texture!",
-                    tmpImage->w, tmpImage->h);
-    }
-
-    // Make sure the alpha channel is not used, but copied to destination
-    SDL_SetAlpha(tmpImage, 0, SDL_ALPHA_OPAQUE);
-
-    // Determine 32-bit masks based on byte order
-    Uint32 rmask, gmask, bmask, amask;
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    rmask = 0xff000000;
-    gmask = 0x00ff0000;
-    bmask = 0x0000ff00;
-    amask = 0x000000ff;
-#else
-    rmask = 0x000000ff;
-    gmask = 0x0000ff00;
-    bmask = 0x00ff0000;
-    amask = 0xff000000;
-#endif
-
-    SDL_Surface *oldImage = nullptr;
-    if (tmpImage->format->BitsPerPixel != 32
-        || realWidth != width || realHeight != height
-        || rmask != tmpImage->format->Rmask
-        || gmask != tmpImage->format->Gmask
-        || amask != tmpImage->format->Amask)
-    {
-        oldImage = tmpImage;
-        tmpImage = SDL_CreateRGBSurface(SDL_SWSURFACE, realWidth, realHeight,
-            32, rmask, gmask, bmask, amask);
-
-        if (!tmpImage)
-        {
-            logger->log("Error, image convert failed: out of memory");
-            return nullptr;
-        }
-        SDL_BlitSurface(oldImage, nullptr, tmpImage, nullptr);
-    }
-
-    GLuint texture;
-    glGenTextures(1, &texture);
-    if (mUseOpenGL == 1)
-        OpenGLGraphics::bindTexture(mTextureType, texture);
-    else if (mUseOpenGL == 2)
-        OpenGL1Graphics::bindTexture(mTextureType, texture);
-
-    if (SDL_MUSTLOCK(tmpImage))
-        SDL_LockSurface(tmpImage);
-
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-    if (mBlur)
-    {
-        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    }
-    else
-    {
-        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    }
-
-    glTexImage2D(mTextureType, 0, mInternalTextureType,
-        tmpImage->w, tmpImage->h,
-        0, GL_RGBA, GL_UNSIGNED_BYTE, tmpImage->pixels);
-
-/*
-    GLint compressed;
-    glGetTexLevelParameteriv(mTextureType, 0,
-        GL_TEXTURE_COMPRESSED_ARB, &compressed);
-    if (compressed)
-        logger->log("image compressed");
-    else
-        logger->log("image not compressed");
-*/
-
-#ifdef DEBUG_OPENGL_LEAKS
-    textures_count ++;
-#endif
-
-    if (SDL_MUSTLOCK(tmpImage))
-        SDL_UnlockSurface(tmpImage);
-
-    if (oldImage)
-        SDL_FreeSurface(tmpImage);
-
-    GLenum error = glGetError();
-    if (error)
-    {
-        std::string errmsg = "Unknown error";
-        switch (error)
-        {
-            case GL_INVALID_ENUM:
-                errmsg = "GL_INVALID_ENUM";
-                break;
-            case GL_INVALID_VALUE:
-                errmsg = "GL_INVALID_VALUE";
-                break;
-            case GL_INVALID_OPERATION:
-                errmsg = "GL_INVALID_OPERATION";
-                break;
-            case GL_STACK_OVERFLOW:
-                errmsg = "GL_STACK_OVERFLOW";
-                break;
-            case GL_STACK_UNDERFLOW:
-                errmsg = "GL_STACK_UNDERFLOW";
-                break;
-            case GL_OUT_OF_MEMORY:
-                errmsg = "GL_OUT_OF_MEMORY";
-                break;
-            default:
-                break;
-        }
-        logger->log("Error: Image GL import failed: %s", errmsg.c_str());
-        return nullptr;
-    }
-
-    return new Image(texture, width, height, realWidth, realHeight);
-}
-
-void Image::setLoadAsOpenGL(int useOpenGL)
-{
-    Image::mUseOpenGL = useOpenGL;
-}
-
-int Image::powerOfTwo(int input)
-{
-    int value;
-    if (mTextureType == GL_TEXTURE_2D)
-    {
-        value = 1;
-        while (value < input && value < mTextureSize)
-            value <<= 1;
-    }
-    else
-    {
-        value = input;
-    }
-    return value >= mTextureSize ? mTextureSize : value;
-}
-#endif
-
 Image *Image::getSubImage(int x, int y, int width, int height)
 {
     // Create a new clipped sub-image
 #ifdef USE_OPENGL
-    if (mUseOpenGL)
+    if (ImageHelper::mUseOpenGL)
     {
         return new SubImage(this, mGLImage, x, y, width, height,
                             mTexWidth, mTexHeight);
@@ -946,22 +336,6 @@ void Image::SDLTerminateAlphaCache()
     mUseAlphaCache = false;
 }
 
-void Image::dumpSurfaceFormat(SDL_Surface *image)
-{
-    if (image->format)
-    {
-        const SDL_PixelFormat * const format = image->format;
-        logger->log("Bytes per pixel: %d", format->BytesPerPixel);
-        logger->log("Alpha: %d", format->alpha);
-        logger->log("Loss: %02x, %02x, %02x, %02x", (int)format->Rloss,
-            (int)format->Gloss, (int)format->Bloss, (int)format->Aloss);
-        logger->log("Shift: %02x, %02x, %02x, %02x", (int)format->Rshift,
-            (int)format->Gshift, (int)format->Bshift, (int)format->Ashift);
-        logger->log("Mask: %08x, %08x, %08x, %08x", format->Rmask,
-            format->Gmask, format->Bmask, format->Amask);
-    }
-}
-
 //============================================================================
 // SubImage Class
 //============================================================================
diff --git a/src/resources/image.h b/src/resources/image.h
index 96bf0f95c..2a3f16c85 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -55,6 +55,7 @@ class Image : public Resource
 {
     friend class CompoundSprite;
     friend class Graphics;
+    friend class ImageHelper;
 #ifdef USE_OPENGL
     friend class OpenGLGraphics;
     friend class OpenGL1Graphics;
@@ -67,36 +68,6 @@ class Image : public Resource
         virtual ~Image();
 
         /**
-         * Loads an image from an SDL_RWops structure.
-         *
-         * @param rw         The SDL_RWops to load the image from.
-         *
-         * @return <code>NULL</code> if an error occurred, a valid pointer
-         *         otherwise.
-         */
-        static Resource *load(SDL_RWops *rw);
-
-        /**
-         * 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.
-         */
-        static Resource *load(SDL_RWops *rw, Dye const &dye);
-
-        /**
-         * Loads an image from an SDL surface.
-         */
-        static Image *load(SDL_Surface *);
-
-        static SDL_Surface* convertTo32Bit(SDL_Surface* tmpImage);
-
-        static Image *createTextSurface(SDL_Surface *tmpImage, float alpha);
-
-        /**
          * Frees the resources created by SDL.
          */
         virtual void unload();
@@ -120,12 +91,6 @@ class Image : public Resource
         { return mBounds.h; }
 
         /**
-         * Tells if the image was loaded using OpenGL or SDL
-         * @return true if OpenGL, false if SDL.
-         */
-        int useOpenGL() const;
-
-        /**
          * Tells if the image has got an alpha channel
          * @return true if it's true, false otherwise.
          */
@@ -164,72 +129,23 @@ class Image : public Resource
         Image* SDLgetScaledImage(int width, int height);
 
         /**
-         * Merges two image SDL_Surfaces together. This is for SDL use only, as
-         * reducing the number of surfaces that SDL has to render can cut down
-         * on the number of blit operations necessary, which in turn can help
-         * improve overall framerates. Don't use unless you are using it to
-         * reduce the number of overall layers that need to be drawn through SDL.
-         */
-        Image *SDLmerge(Image *image, int x, int y);
-
-        /**
          * Get the alpha Channel of a SDL surface.
          */
         Uint8 *SDLgetAlphaChannel() const
         { return mAlphaChannel; }
 
-        SDL_Surface* SDLDuplicateSurface(SDL_Surface* tmpImage);
-
         void SDLCleanCache();
 
         void SDLTerminateAlphaCache();
 
-        static void SDLSetEnableAlphaCache(bool n)
-        { mEnableAlphaCache = n; }
-
-        static bool SDLGetEnableAlphaCache()
-        { return mEnableAlphaCache; }
-
-        static void setEnableAlpha(bool n)
-        { mEnableAlpha = n; }
-
 #ifdef USE_OPENGL
-
         // OpenGL only public functions
 
-        /**
-         * Sets the target image format. Use <code>false</code> for SDL and
-         * <code>true</code> for OpenGL.
-         */
-        static void setLoadAsOpenGL(int useOpenGL);
-
-        static int getLoadAsOpenGL()
-        { return mUseOpenGL; }
-
         int getTextureWidth() const
         { return mTexWidth; }
 
         int getTextureHeight() const
         { return mTexHeight; }
-
-        static int getTextureType()
-        { return mTextureType; }
-
-        static int getInternalTextureType()
-        { return mInternalTextureType; }
-
-        static void setInternalTextureType(int n)
-        { mInternalTextureType = n; }
-
-        static void setBlur(bool n)
-        { mBlur = n; }
-
-        static int mTextureType;
-
-        static int mInternalTextureType;
-
-        static void dumpSurfaceFormat(SDL_Surface *image);
-
 #endif
 
         bool isHasAlphaChannel() const
@@ -267,9 +183,6 @@ class Image : public Resource
         Image(SDL_Surface *image, bool hasAlphaChannel = false,
               Uint8 *alphaChannel = nullptr);
 
-        /** SDL_Surface to SDL_Surface Image loader */
-        static Image *_SDLload(SDL_Surface *tmpImage);
-
         SDL_Surface *getByAlpha(float alpha);
 
         SDL_Surface *mSDLSurface;
@@ -283,9 +196,6 @@ class Image : public Resource
         bool mIsAlphaVisible;
         bool mIsAlphaCalculated;
 
-        static bool mEnableAlphaCache;
-        static bool mEnableAlpha;
-
         // -----------------------
         // OpenGL protected members
         // -----------------------
@@ -296,19 +206,8 @@ class Image : public Resource
         Image(GLuint glimage, int width, int height,
               int texWidth, int texHeight);
 
-        /**
-         * Returns the first power of two equal or bigger than the input.
-         */
-        static int powerOfTwo(int input);
-
-        static Image *_GLload(SDL_Surface *tmpImage);
-
         GLuint mGLImage;
         int mTexWidth, mTexHeight;
-
-        static int mUseOpenGL;
-        static int mTextureSize;
-        static bool mBlur;
 #endif
 };
 
diff --git a/src/resources/imagehelper.cpp b/src/resources/imagehelper.cpp
new file mode 100644
index 000000000..9ee52267e
--- /dev/null
+++ b/src/resources/imagehelper.cpp
@@ -0,0 +1,582 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2012  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 "resources/imagehelper.h"
+
+#include "resources/dye.h"
+#include "resources/resourcemanager.h"
+
+#ifdef USE_OPENGL
+#include "openglgraphics.h"
+#include "opengl1graphics.h"
+#endif
+
+#include "client.h"
+#include "logger.h"
+#include "main.h"
+
+#include "utils/stringutils.h"
+
+#include "resources/image.h"
+
+#include <SDL_image.h>
+#include <SDL_rotozoom.h>
+
+#include "debug.h"
+
+#ifdef USE_OPENGL
+int ImageHelper::mUseOpenGL = 0;
+int ImageHelper::mTextureType = 0;
+int ImageHelper::mInternalTextureType = GL_RGBA8;
+int ImageHelper::mTextureSize = 0;
+bool ImageHelper::mBlur = true;
+#endif
+bool ImageHelper::mEnableAlphaCache = false;
+bool ImageHelper::mEnableAlpha = true;
+
+Resource *ImageHelper::load(SDL_RWops *rw)
+{
+    SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
+
+    if (!tmpImage)
+    {
+        logger->log("Error, image load failed: %s", IMG_GetError());
+        return nullptr;
+    }
+
+    Image *image = load(tmpImage);
+
+    SDL_FreeSurface(tmpImage);
+    return image;
+}
+
+Resource *ImageHelper::load(SDL_RWops *rw, Dye const &dye)
+{
+    SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
+
+    if (!tmpImage)
+    {
+        logger->log("Error, image load failed: %s", IMG_GetError());
+        return nullptr;
+    }
+
+    SDL_Surface *surf = nullptr;
+    SDL_PixelFormat rgba;
+    rgba.palette = nullptr;
+    rgba.BitsPerPixel = 32;
+    rgba.BytesPerPixel = 4;
+    rgba.colorkey = 0;
+    rgba.alpha = 255;
+    if (mUseOpenGL)
+    {
+        surf = convertTo32Bit(tmpImage);
+        SDL_FreeSurface(tmpImage);
+
+        Uint32 *pixels = static_cast<Uint32 *>(surf->pixels);
+        DyePalette *pal = dye.getSPalete();
+
+        if (pal)
+        {
+            for (Uint32 *p_end = pixels + surf->w * surf->h;
+                pixels != p_end; ++pixels)
+            {
+                Uint8 *p = (Uint8 *)pixels;
+                const int alpha = *p & 255;
+                if (!alpha)
+                    continue;
+                pal->replaceOGLColor(p);
+            }
+        }
+        else
+        {
+            for (Uint32 *p_end = pixels + surf->w * surf->h;
+                pixels != p_end; ++pixels)
+            {
+                const Uint32 p = *pixels;
+                const int alpha = (p >> 24) & 255;
+                if (!alpha)
+                    continue;
+                int v[3];
+                v[0] = (p) & 255;
+                v[1] = (p >> 8) & 255;
+                v[2] = (p >> 16 ) & 255;
+                dye.update(v);
+                *pixels = (v[0]) | (v[1] << 8) | (v[2] << 16) | (alpha << 24);
+            }
+        }
+    }
+    else
+    {
+        rgba.Rmask = 0xFF000000; rgba.Rloss = 0; rgba.Rshift = 24;
+        rgba.Gmask = 0x00FF0000; rgba.Gloss = 0; rgba.Gshift = 16;
+        rgba.Bmask = 0x0000FF00; rgba.Bloss = 0; rgba.Bshift = 8;
+        rgba.Amask = 0x000000FF; rgba.Aloss = 0; rgba.Ashift = 0;
+
+        surf = SDL_ConvertSurface(tmpImage, &rgba, SDL_SWSURFACE);
+        SDL_FreeSurface(tmpImage);
+
+        Uint32 *pixels = static_cast<Uint32 *>(surf->pixels);
+        DyePalette *pal = dye.getSPalete();
+
+        if (pal)
+        {
+            for (Uint32 *p_end = pixels + surf->w * surf->h;
+                pixels != p_end; ++pixels)
+            {
+                Uint8 *p = (Uint8 *)pixels;
+                const int alpha = *p & 255;
+                if (!alpha)
+                    continue;
+                pal->replaceColor(p + 1);
+            }
+        }
+        else
+        {
+            for (Uint32 *p_end = pixels + surf->w * surf->h;
+                pixels != p_end; ++pixels)
+            {
+                const Uint32 p = *pixels;
+                const int alpha = p & 255;
+                if (!alpha)
+                    continue;
+                int v[3];
+                v[0] = (p >> 24) & 255;
+                v[1] = (p >> 16) & 255;
+                v[2] = (p >> 8 ) & 255;
+                dye.update(v);
+                *pixels = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | alpha;
+            }
+        }
+    }
+
+    Image *image = load(surf);
+    SDL_FreeSurface(surf);
+    return image;
+}
+
+Image *ImageHelper::load(SDL_Surface *tmpImage)
+{
+#ifdef USE_OPENGL
+    if (mUseOpenGL)
+        return _GLload(tmpImage);
+#endif
+    return _SDLload(tmpImage);
+}
+
+Image *ImageHelper::createTextSurface(SDL_Surface *tmpImage, float alpha)
+{
+    if (!tmpImage)
+        return nullptr;
+
+    Image *img;
+#ifdef USE_OPENGL
+    if (mUseOpenGL)
+    {
+        img = _GLload(tmpImage);
+        if (img)
+            img->setAlpha(alpha);
+        return img;
+    }
+#endif
+
+    bool hasAlpha = false;
+    bool converted = false;
+
+    const int sz = tmpImage->w * tmpImage->h;
+
+    // The alpha channel to be filled with alpha values
+    Uint8 *alphaChannel = new Uint8[sz];
+
+    const SDL_PixelFormat * const fmt = tmpImage->format;
+    if (fmt->Amask)
+    {
+        for (int i = 0; i < sz; ++ i)
+        {
+            Uint32 c = (static_cast<Uint32*>(tmpImage->pixels))[i];
+
+            unsigned v = (c & fmt->Amask) >> fmt->Ashift;
+            Uint8 a = (v << fmt->Aloss) + (v >> (8 - (fmt->Aloss << 1)));
+
+            Uint8 a2 = static_cast<Uint8>(static_cast<float>(a) * alpha);
+
+            c &= ~fmt->Amask;
+            c |= ((a2 >> fmt->Aloss) << fmt->Ashift & fmt->Amask);
+            (static_cast<Uint32*>(tmpImage->pixels))[i] = c;
+
+            if (a != 255)
+                hasAlpha = true;
+
+            alphaChannel[i] = a;
+        }
+    }
+
+    SDL_Surface *image;
+
+    // Convert the surface to the current display format
+    if (hasAlpha)
+    {
+        image = SDL_DisplayFormatAlpha(tmpImage);
+    }
+    else
+    {
+        image = SDL_DisplayFormat(tmpImage);
+
+        // We also delete the alpha channel since
+        // it's not used.
+        delete [] alphaChannel;
+        alphaChannel = nullptr;
+    }
+
+    if (!image)
+    {
+        logger->log1("Error: Image convert failed.");
+        delete [] alphaChannel;
+        return nullptr;
+    }
+
+    if (converted)
+        SDL_FreeSurface(tmpImage);
+
+    img = new Image(image, hasAlpha, alphaChannel);
+    img->mAlpha = alpha;
+    return img;
+}
+
+SDL_Surface* ImageHelper::convertTo32Bit(SDL_Surface* tmpImage)
+{
+    if (!tmpImage)
+        return nullptr;
+    SDL_PixelFormat RGBAFormat;
+    RGBAFormat.palette = nullptr;
+    RGBAFormat.colorkey = 0;
+    RGBAFormat.alpha = 0;
+    RGBAFormat.BitsPerPixel = 32;
+    RGBAFormat.BytesPerPixel = 4;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    RGBAFormat.Rmask = 0xFF000000;
+    RGBAFormat.Rshift = 0;
+    RGBAFormat.Rloss = 0;
+    RGBAFormat.Gmask = 0x00FF0000;
+    RGBAFormat.Gshift = 8;
+    RGBAFormat.Gloss = 0;
+    RGBAFormat.Bmask = 0x0000FF00;
+    RGBAFormat.Bshift = 16;
+    RGBAFormat.Bloss = 0;
+    RGBAFormat.Amask = 0x000000FF;
+    RGBAFormat.Ashift = 24;
+    RGBAFormat.Aloss = 0;
+#else
+    RGBAFormat.Rmask = 0x000000FF;
+    RGBAFormat.Rshift = 24;
+    RGBAFormat.Rloss = 0;
+    RGBAFormat.Gmask = 0x0000FF00;
+    RGBAFormat.Gshift = 16;
+    RGBAFormat.Gloss = 0;
+    RGBAFormat.Bmask = 0x00FF0000;
+    RGBAFormat.Bshift = 8;
+    RGBAFormat.Bloss = 0;
+    RGBAFormat.Amask = 0xFF000000;
+    RGBAFormat.Ashift = 0;
+    RGBAFormat.Aloss = 0;
+#endif
+    return SDL_ConvertSurface(tmpImage, &RGBAFormat, SDL_SWSURFACE);
+}
+
+SDL_Surface* ImageHelper::SDLDuplicateSurface(SDL_Surface* tmpImage)
+{
+    if (!tmpImage || !tmpImage->format)
+        return nullptr;
+
+    return SDL_ConvertSurface(tmpImage, tmpImage->format, SDL_SWSURFACE);
+}
+
+Image *ImageHelper::_SDLload(SDL_Surface *tmpImage)
+{
+    if (!tmpImage)
+        return nullptr;
+
+    bool hasAlpha = false;
+    bool converted = false;
+
+    if (tmpImage->format->BitsPerPixel != 32)
+    {
+        tmpImage = convertTo32Bit(tmpImage);
+
+        if (!tmpImage)
+            return nullptr;
+        converted = true;
+    }
+
+    const int sz = tmpImage->w * tmpImage->h;
+
+    // The alpha channel to be filled with alpha values
+    Uint8 *alphaChannel = new Uint8[sz];
+
+    // Figure out whether the image uses its alpha layer
+    if (!tmpImage->format->palette)
+    {
+        const SDL_PixelFormat * const fmt = tmpImage->format;
+        if (fmt->Amask)
+        {
+            for (int i = 0; i < sz; ++ i)
+            {
+                unsigned v = ((static_cast<Uint32*>(tmpImage->pixels))[i]
+                    & fmt->Amask) >> fmt->Ashift;
+                Uint8 a = (v << fmt->Aloss) + (v >> (8 - (fmt->Aloss << 1)));
+
+                if (a != 255)
+                    hasAlpha = true;
+
+                alphaChannel[i] = a;
+            }
+        }
+        else
+        {
+            if (SDL_ALPHA_OPAQUE != 255)
+            {
+                hasAlpha = true;
+                memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
+            }
+        }
+    }
+    else
+    {
+        if (SDL_ALPHA_OPAQUE != 255)
+        {
+            hasAlpha = true;
+            memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
+        }
+    }
+
+    SDL_Surface *image;
+
+    // Convert the surface to the current display format
+    if (hasAlpha)
+    {
+        image = SDL_DisplayFormatAlpha(tmpImage);
+    }
+    else
+    {
+        image = SDL_DisplayFormat(tmpImage);
+
+        // We also delete the alpha channel since
+        // it's not used.
+        delete [] alphaChannel;
+        alphaChannel = nullptr;
+    }
+
+    if (!image)
+    {
+        logger->log1("Error: Image convert failed.");
+        delete [] alphaChannel;
+        return nullptr;
+    }
+
+    if (converted)
+        SDL_FreeSurface(tmpImage);
+
+    return new Image(image, hasAlpha, alphaChannel);
+}
+
+#ifdef USE_OPENGL
+int ImageHelper::powerOfTwo(int input)
+{
+    int value;
+    if (mTextureType == GL_TEXTURE_2D)
+    {
+        value = 1;
+        while (value < input && value < mTextureSize)
+            value <<= 1;
+    }
+    else
+    {
+        value = input;
+    }
+    return value >= mTextureSize ? mTextureSize : value;
+}
+
+Image *ImageHelper::_GLload(SDL_Surface *tmpImage)
+{
+    if (!tmpImage)
+        return nullptr;
+
+    // Flush current error flag.
+    glGetError();
+
+    int width = tmpImage->w;
+    int height = tmpImage->h;
+    int realWidth = powerOfTwo(width);
+    int realHeight = powerOfTwo(height);
+
+    if (realWidth < width || realHeight < height)
+    {
+        logger->log("Warning: image too large, cropping to %dx%d texture!",
+                    tmpImage->w, tmpImage->h);
+    }
+
+    // Make sure the alpha channel is not used, but copied to destination
+    SDL_SetAlpha(tmpImage, 0, SDL_ALPHA_OPAQUE);
+
+    // Determine 32-bit masks based on byte order
+    Uint32 rmask, gmask, bmask, amask;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    rmask = 0xff000000;
+    gmask = 0x00ff0000;
+    bmask = 0x0000ff00;
+    amask = 0x000000ff;
+#else
+    rmask = 0x000000ff;
+    gmask = 0x0000ff00;
+    bmask = 0x00ff0000;
+    amask = 0xff000000;
+#endif
+
+    SDL_Surface *oldImage = nullptr;
+    if (tmpImage->format->BitsPerPixel != 32
+        || realWidth != width || realHeight != height
+        || rmask != tmpImage->format->Rmask
+        || gmask != tmpImage->format->Gmask
+        || amask != tmpImage->format->Amask)
+    {
+        oldImage = tmpImage;
+        tmpImage = SDL_CreateRGBSurface(SDL_SWSURFACE, realWidth, realHeight,
+            32, rmask, gmask, bmask, amask);
+
+        if (!tmpImage)
+        {
+            logger->log("Error, image convert failed: out of memory");
+            return nullptr;
+        }
+        SDL_BlitSurface(oldImage, nullptr, tmpImage, nullptr);
+    }
+
+    GLuint texture;
+    glGenTextures(1, &texture);
+    if (mUseOpenGL == 1)
+        OpenGLGraphics::bindTexture(mTextureType, texture);
+    else if (mUseOpenGL == 2)
+        OpenGL1Graphics::bindTexture(mTextureType, texture);
+
+    if (SDL_MUSTLOCK(tmpImage))
+        SDL_LockSurface(tmpImage);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    if (mBlur)
+    {
+        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    }
+    else
+    {
+        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    }
+
+    glTexImage2D(mTextureType, 0, mInternalTextureType,
+        tmpImage->w, tmpImage->h,
+        0, GL_RGBA, GL_UNSIGNED_BYTE, tmpImage->pixels);
+
+/*
+    GLint compressed;
+    glGetTexLevelParameteriv(mTextureType, 0,
+        GL_TEXTURE_COMPRESSED_ARB, &compressed);
+    if (compressed)
+        logger->log("image compressed");
+    else
+        logger->log("image not compressed");
+*/
+
+#ifdef DEBUG_OPENGL_LEAKS
+    textures_count ++;
+#endif
+
+    if (SDL_MUSTLOCK(tmpImage))
+        SDL_UnlockSurface(tmpImage);
+
+    if (oldImage)
+        SDL_FreeSurface(tmpImage);
+
+    GLenum error = glGetError();
+    if (error)
+    {
+        std::string errmsg = "Unknown error";
+        switch (error)
+        {
+            case GL_INVALID_ENUM:
+                errmsg = "GL_INVALID_ENUM";
+                break;
+            case GL_INVALID_VALUE:
+                errmsg = "GL_INVALID_VALUE";
+                break;
+            case GL_INVALID_OPERATION:
+                errmsg = "GL_INVALID_OPERATION";
+                break;
+            case GL_STACK_OVERFLOW:
+                errmsg = "GL_STACK_OVERFLOW";
+                break;
+            case GL_STACK_UNDERFLOW:
+                errmsg = "GL_STACK_UNDERFLOW";
+                break;
+            case GL_OUT_OF_MEMORY:
+                errmsg = "GL_OUT_OF_MEMORY";
+                break;
+            default:
+                break;
+        }
+        logger->log("Error: Image GL import failed: %s", errmsg.c_str());
+        return nullptr;
+    }
+
+    return new Image(texture, width, height, realWidth, realHeight);
+}
+
+void ImageHelper::setLoadAsOpenGL(int useOpenGL)
+{
+    ImageHelper::mUseOpenGL = useOpenGL;
+}
+
+#endif
+
+void ImageHelper::dumpSurfaceFormat(SDL_Surface *image)
+{
+    if (image->format)
+    {
+        const SDL_PixelFormat * const format = image->format;
+        logger->log("Bytes per pixel: %d", format->BytesPerPixel);
+        logger->log("Alpha: %d", format->alpha);
+        logger->log("Loss: %02x, %02x, %02x, %02x", (int)format->Rloss,
+            (int)format->Gloss, (int)format->Bloss, (int)format->Aloss);
+        logger->log("Shift: %02x, %02x, %02x, %02x", (int)format->Rshift,
+            (int)format->Gshift, (int)format->Bshift, (int)format->Ashift);
+        logger->log("Mask: %08x, %08x, %08x, %08x", format->Rmask,
+            format->Gmask, format->Bmask, format->Amask);
+    }
+}
+
+int ImageHelper::useOpenGL()
+{
+#ifdef USE_OPENGL
+    return mUseOpenGL;
+#else
+    return 0;
+#endif
+}
diff --git a/src/resources/imagehelper.h b/src/resources/imagehelper.h
new file mode 100644
index 000000000..680794625
--- /dev/null
+++ b/src/resources/imagehelper.h
@@ -0,0 +1,170 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2012  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 IMAGEHELPER_H
+#define IMAGEHELPER_H
+
+#include "localconsts.h"
+#include "main.h"
+
+#include "resources/resource.h"
+
+#include <SDL.h>
+
+#ifdef USE_OPENGL
+
+/* The definition of OpenGL extensions by SDL is giving problems with recent
+ * gl.h headers, since they also include these definitions. As we're not using
+ * extensions anyway it's safe to just disable the SDL version.
+ */
+//#define NO_SDL_GLEXT
+#define GL_GLEXT_PROTOTYPES 1
+
+#include <SDL_opengl.h>
+#endif
+
+#include <map>
+
+class Dye;
+class Image;
+
+struct Position;
+
+/**
+ * Defines a class for loading and storing images.
+ */
+class ImageHelper : public Resource
+{
+    friend class CompoundSprite;
+    friend class Graphics;
+    friend class Image;
+#ifdef USE_OPENGL
+    friend class OpenGLGraphics;
+    friend class OpenGL1Graphics;
+#endif
+
+    public:
+        /**
+         * Loads an image from an SDL_RWops structure.
+         *
+         * @param rw         The SDL_RWops to load the image from.
+         *
+         * @return <code>NULL</code> if an error occurred, a valid pointer
+         *         otherwise.
+         */
+        static Resource *load(SDL_RWops *rw);
+
+        /**
+         * 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.
+         */
+        static Resource *load(SDL_RWops *rw, Dye const &dye);
+
+        /**
+         * Loads an image from an SDL surface.
+         */
+        static Image *load(SDL_Surface *);
+
+        static SDL_Surface *convertTo32Bit(SDL_Surface* tmpImage);
+
+        static Image *createTextSurface(SDL_Surface *tmpImage, float alpha);
+
+        static void SDLSetEnableAlphaCache(bool n)
+        { mEnableAlphaCache = n; }
+
+        static bool SDLGetEnableAlphaCache()
+        { return mEnableAlphaCache; }
+
+        static void setEnableAlpha(bool n)
+        { mEnableAlpha = n; }
+
+#ifdef USE_OPENGL
+
+        // OpenGL only public functions
+
+        /**
+         * Sets the target image format. Use <code>false</code> for SDL and
+         * <code>true</code> for OpenGL.
+         */
+        static void setLoadAsOpenGL(int useOpenGL);
+
+        static int getLoadAsOpenGL()
+        { return mUseOpenGL; }
+
+        static int getTextureType()
+        { return mTextureType; }
+
+        static int getInternalTextureType()
+        { return mInternalTextureType; }
+
+        static void setInternalTextureType(int n)
+        { mInternalTextureType = n; }
+
+        static void setBlur(bool n)
+        { mBlur = n; }
+
+        static int mTextureType;
+
+        static int mInternalTextureType;
+
+        static void dumpSurfaceFormat(SDL_Surface *image);
+
+        static SDL_Surface* SDLDuplicateSurface(SDL_Surface* tmpImage);
+
+#endif
+
+         /**
+         * Tells if the image was loaded using OpenGL or SDL
+         * @return true if OpenGL, false if SDL.
+         */
+        static int useOpenGL();
+
+    protected:
+        /** SDL_Surface to SDL_Surface Image loader */
+        static Image *_SDLload(SDL_Surface *tmpImage);
+
+        static bool mEnableAlphaCache;
+        static bool mEnableAlpha;
+
+        // -----------------------
+        // OpenGL protected members
+        // -----------------------
+#ifdef USE_OPENGL
+        /**
+         * Returns the first power of two equal or bigger than the input.
+         */
+        static int powerOfTwo(int input);
+
+        static Image *_GLload(SDL_Surface *tmpImage);
+
+        static int mUseOpenGL;
+        static int mTextureSize;
+        static bool mBlur;
+#endif
+};
+
+#endif
diff --git a/src/resources/resourcemanager.cpp b/src/resources/resourcemanager.cpp
index 12ad310ed..62a604ebe 100644
--- a/src/resources/resourcemanager.cpp
+++ b/src/resources/resourcemanager.cpp
@@ -29,6 +29,7 @@
 
 #include "resources/dye.h"
 #include "resources/image.h"
+#include "resources/imagehelper.h"
 #include "resources/imageset.h"
 #include "resources/music.h"
 #include "resources/soundeffect.h"
@@ -456,8 +457,8 @@ struct DyedImageLoader
             delete d;
             return nullptr;
         }
-        Resource *res = d ? Image::load(rw, *d)
-                          : Image::load(rw);
+        Resource *res = d ? ImageHelper::load(rw, *d)
+                          : ImageHelper::load(rw);
         delete d;
         return res;
     }