Cleaned up the image code a bit...

1 files changed, 146 insertions, 138 deletions

diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index 9af3059a..b51e1e1e 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -133,141 +133,11 @@ Image *Image::load(SDL_Surface *tmpImage)
 #ifdef USE_OPENGL
     if (mUseOpenGL)
     {
-        // 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 = 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 NULL;
-        }
-
-        SDL_BlitSurface(oldImage, NULL, tmpImage, NULL);
-
-        GLuint texture;
-        glGenTextures(1, &texture);
-        glBindTexture(mTextureType, texture);
-
-        if (SDL_MUSTLOCK(tmpImage))
-            SDL_LockSurface(tmpImage);
-
-        glTexImage2D(
-                mTextureType, 0, 4,
-                tmpImage->w, tmpImage->h,
-                0, GL_RGBA, GL_UNSIGNED_BYTE,
-                tmpImage->pixels);
-
-        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-        if (SDL_MUSTLOCK(tmpImage)) {
-            SDL_UnlockSurface(tmpImage);
-        }
-
-        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;
-            }
-            logger->log("Error: Image GL import failed: %s", errmsg.c_str());
-            return NULL;
-        }
-
-        return new Image(texture, width, height, realWidth, realHeight);
+        return _GLload(tmpImage);
     }
 #endif
 
-    bool hasAlpha = false;
-
-    if (tmpImage->format->BitsPerPixel == 32)
-    {
-        // Figure out whether the image uses its alpha layer
-        for (int i = 0; i < tmpImage->w * tmpImage->h; ++i)
-        {
-            Uint8 r, g, b, a;
-            SDL_GetRGBA(
-                    ((Uint32*) tmpImage->pixels)[i],
-                    tmpImage->format,
-                    &r, &g, &b, &a);
-
-            if (a != 255)
-            {
-                hasAlpha = true;
-                break;
-            }
-        }
-    }
-
-    SDL_Surface *image;
-
-    // Convert the surface to the current display format
-    if (hasAlpha)
-        image = SDL_DisplayFormatAlpha(tmpImage);
-    else
-        image = SDL_DisplayFormat(tmpImage);
-
-    if (!image)
-    {
-        logger->log("Error: Image convert failed.");
-        return NULL;
-    }
-
-    return new Image(image);
+    return _SDLload(tmpImage);
 }
 
 void Image::unload()
@@ -313,7 +183,7 @@ void Image::setAlpha(float a)
     }
 }
 
-Image* Image::merge(Image *image, int x, int y)
+Image* Image::SDLmerge(Image *image, int x, int y)
 {
     SDL_Surface* surface = new SDL_Surface(*(image->mImage));
 
@@ -388,11 +258,6 @@ Image* Image::merge(Image *image, int x, int y)
     return newImage;
 }
 
-float Image::getAlpha() const
-{
-    return mAlpha;
-}
-
 Image* Image::SDLgetScaledImage(int width, int height)
 {
     // No scaling on incorrect new values.
@@ -421,7 +286,150 @@ Image* Image::SDLgetScaledImage(int width, int height)
     return scaledImage;
 }
 
+Image *Image::_SDLload(SDL_Surface *tmpImage)
+{
+    if (!tmpImage)
+        return NULL;
+
+    bool hasAlpha = false;
+
+    if (tmpImage->format->BitsPerPixel == 32)
+    {
+        // Figure out whether the image uses its alpha layer
+        for (int i = 0; i < tmpImage->w * tmpImage->h; ++i)
+        {
+            Uint8 r, g, b, a;
+            SDL_GetRGBA(
+                    ((Uint32*) tmpImage->pixels)[i],
+                    tmpImage->format,
+                    &r, &g, &b, &a);
+
+            if (a != 255)
+            {
+                hasAlpha = true;
+                break;
+            }
+        }
+    }
+
+    SDL_Surface *image;
+
+    // Convert the surface to the current display format
+    if (hasAlpha)
+        image = SDL_DisplayFormatAlpha(tmpImage);
+    else
+        image = SDL_DisplayFormat(tmpImage);
+
+    if (!image)
+    {
+        logger->log("Error: Image convert failed.");
+        return NULL;
+    }
+
+    return new Image(image);
+}
+
 #ifdef USE_OPENGL
+Image *Image::_GLload(SDL_Surface *tmpImage)
+{
+        // 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 = 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 NULL;
+        }
+
+        SDL_BlitSurface(oldImage, NULL, tmpImage, NULL);
+
+        GLuint texture;
+        glGenTextures(1, &texture);
+        glBindTexture(mTextureType, texture);
+
+        if (SDL_MUSTLOCK(tmpImage))
+            SDL_LockSurface(tmpImage);
+
+        glTexImage2D(
+                mTextureType, 0, 4,
+                tmpImage->w, tmpImage->h,
+                0, GL_RGBA, GL_UNSIGNED_BYTE,
+                tmpImage->pixels);
+
+        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        if (SDL_MUSTLOCK(tmpImage)) {
+            SDL_UnlockSurface(tmpImage);
+        }
+
+        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;
+            }
+            logger->log("Error: Image GL import failed: %s", errmsg.c_str());
+            return NULL;
+        }
+
+        return new Image(texture, width, height, realWidth, realHeight);
+}
+
 void Image::setLoadAsOpenGL(bool useOpenGL)
 {
     Image::mUseOpenGL = useOpenGL;