Turned the OpenGL and disable transparency options as static members.

- Now OpenGL and the transparency disabling are set at startup and
not read again for displaying graphics, preventing graphic errors
before startup.

- We also agreed long time ago that SDL specific functions
should have a SDL prefix. The header has been rearranged a bit
to do so.

- Also fixed a possible discrepancy in the hasAlphaChannel() function.

Reviewed-by: CodyMartin.

Resolves: Mana-Mantis: #260.

7 files changed, 66 insertions, 46 deletions

diff --git a/src/client.cpp b/src/client.cpp
index 2681a254..3ed3fb34 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -253,7 +253,7 @@ Client::Client(const Options &options):
                                 "Exiting.", mLocalDataDir.c_str()));
     }
 
-    Image::setEnableAlphaCache(config.getValue("alphaCache", true));
+    Image::SDLsetEnableAlphaCache(config.getValue("alphaCache", true));
 
 #if defined __APPLE__
     CFBundleRef mainBundle = CFBundleGetMainBundle();
@@ -317,9 +317,14 @@ Client::Client(const Options &options):
     }
 #endif
 
-#ifdef USE_OPENGL
     bool useOpenGL = !mOptions.noOpenGL && (config.getValue("opengl", 0) == 1);
 
+    // Set up the transparency option for low CPU when not using OpenGL.
+    if (!useOpenGL && (config.getValue("lowcpu", 0) == 1))
+        Image::SDLdisableTransparency();
+
+#ifdef USE_OPENGL
+
     // Setup image loading for the right image format
     Image::setLoadAsOpenGL(useOpenGL);
 
diff --git a/src/gui/widgets/desktop.cpp b/src/gui/widgets/desktop.cpp
index 2a80cc11..23dd3eb5 100644
--- a/src/gui/widgets/desktop.cpp
+++ b/src/gui/widgets/desktop.cpp
@@ -85,7 +85,7 @@ void Desktop::draw(gcn::Graphics *graphics)
 
     if (mWallpaper)
     {
-        if (!mWallpaper->isAnOpenGLOne())
+        if (!mWallpaper->useOpenGL())
             g->drawImage(mWallpaper,
                 (getWidth() - mWallpaper->getWidth()) / 2,
                 (getHeight() - mWallpaper->getHeight()) / 2);
@@ -114,7 +114,7 @@ void Desktop::setBestFittingWallpaper()
         if (mWallpaper)
             mWallpaper->decRef();
 
-        if (!nWallPaper->isAnOpenGLOne() && (nWallPaper->getWidth() != getWidth()
+        if (!nWallPaper->useOpenGL() && (nWallPaper->getWidth() != getWidth()
             || nWallPaper->getHeight() != getHeight()))
         {
             // We rescale to obtain a fullscreen wallpaper...
diff --git a/src/map.cpp b/src/map.cpp
index 2de0a4a8..f845f2ff 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -331,7 +331,7 @@ void Map::draw(Graphics *graphics, int scrollX, int scrollY)
     }
 
     // If the transparency hasn't been disabled,
-    if (config.getValue("opengl", false) || !config.getValue("lowcpu", true))
+    if (Image::useOpenGL() || !Image::SDLisTransparencyDisabled())
     {
         // We draw beings with a lower opacity to make them visible
         // even when covered by a wall or some other elements...
diff --git a/src/resources/ambientlayer.cpp b/src/resources/ambientlayer.cpp
index 50fe8bd9..b662ddeb 100644
--- a/src/resources/ambientlayer.cpp
+++ b/src/resources/ambientlayer.cpp
@@ -33,7 +33,7 @@ AmbientLayer::AmbientLayer(Image *img, float parallax,
     mKeepRatio(keepRatio)
 {
 
-    if (keepRatio && !mImage->isAnOpenGLOne()
+    if (keepRatio && !mImage->useOpenGL()
         && defaultScreenWidth != 0
         && defaultScreenHeight != 0
         && graphics->getWidth() != defaultScreenWidth
@@ -92,7 +92,7 @@ void AmbientLayer::update(int timePassed, float dx, float dy)
 
 void AmbientLayer::draw(Graphics *graphics, int x, int y)
 {
-    if (!mImage->isAnOpenGLOne() || !mKeepRatio)
+    if (!mImage->useOpenGL() || !mKeepRatio)
         graphics->drawImagePattern(mImage,
             (int) -mPosX, (int) -mPosY, x + (int) mPosX, y + (int) mPosY);
     else
diff --git a/src/resources/ambientoverlay.cpp b/src/resources/ambientoverlay.cpp
index 64a46676..aba12f84 100644
--- a/src/resources/ambientoverlay.cpp
+++ b/src/resources/ambientoverlay.cpp
@@ -34,7 +34,7 @@ AmbientOverlay::AmbientOverlay(Image *img, float parallax,
     mKeepRatio(keepRatio)
 {
 
-    if (keepRatio && !mImage->isAnOpenGLOne()
+    if (keepRatio && !mImage->useOpenGL()
         && defaultScreenWidth != 0
         && defaultScreenHeight != 0
         && graphics->getWidth() != defaultScreenWidth
@@ -92,7 +92,7 @@ void AmbientOverlay::update(int timePassed, float dx, float dy)
 
 void AmbientOverlay::draw(Graphics *graphics, int x, int y)
 {
-    if (!mImage->isAnOpenGLOne() || !mKeepRatio)
+    if (!mImage->useOpenGL() || !mKeepRatio)
         graphics->drawImagePattern(mImage,
             (int) -mPosX, (int) -mPosY, x + (int) mPosX, y + (int) mPosY);
     else
diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index 42a6ab56..63f1bd2c 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -41,11 +41,14 @@ int Image::mTextureSize = 0;
 #endif
 bool Image::mEnableAlphaCache = false;
 
+// The low CPU mode is disabled per default
+bool Image::mDisableTransparency = false;
+
 Image::Image(SDL_Surface *image, bool hasAlphaChannel, Uint8 *alphaChannel):
     mAlpha(1.0f),
-    mHasAlphaChannel(hasAlphaChannel),
     mSDLSurface(image),
-    mAlphaChannel(alphaChannel)
+    mAlphaChannel(alphaChannel),
+    mHasAlphaChannel(hasAlphaChannel)
 {
 #ifdef USE_OPENGL
     mGLImage = 0;
@@ -73,9 +76,9 @@ Image::Image(SDL_Surface *image, bool hasAlphaChannel, Uint8 *alphaChannel):
 #ifdef USE_OPENGL
 Image::Image(GLuint glimage, int width, int height, int texWidth, int texHeight):
     mAlpha(1.0f),
-    mHasAlphaChannel(true),
     mSDLSurface(0),
     mAlphaChannel(0),
+    mHasAlphaChannel(true),
     mUseAlphaCache(false),
     mGLImage(glimage),
     mTexWidth(texWidth),
@@ -172,7 +175,7 @@ Image *Image::load(SDL_Surface *tmpImage)
     return _SDLload(tmpImage);
 }
 
-void Image::cleanCache()
+void Image::SDLcleanCache()
 {
     ResourceManager *resman = ResourceManager::getInstance();
 
@@ -193,7 +196,7 @@ void Image::unload()
 
     if (mSDLSurface)
     {
-        cleanCache();
+        SDLcleanCache();
         // Free the image surface.
         SDL_FreeSurface(mSDLSurface);
         mSDLSurface = NULL;
@@ -211,7 +214,7 @@ void Image::unload()
 #endif
 }
 
-bool Image::isAnOpenGLOne() const
+bool Image::useOpenGL()
 {
 #ifdef USE_OPENGL
     return mUseOpenGL;
@@ -222,15 +225,15 @@ bool Image::isAnOpenGLOne() const
 
 bool Image::hasAlphaChannel()
 {
-    if (mLoaded)
-        return mHasAlphaChannel;
+    if (!mLoaded)
+        return false;
 
 #ifdef USE_OPENGL
     if (mUseOpenGL)
         return true;
 #endif
 
-    return false;
+    return mHasAlphaChannel;
 }
 
 SDL_Surface *Image::getByAlpha(float alpha)
@@ -243,7 +246,7 @@ SDL_Surface *Image::getByAlpha(float alpha)
 
 void Image::setAlpha(float alpha)
 {
-    if (config.getValue("lowcpu", true) == true)
+    if (!useOpenGL() && mDisableTransparency)
         return;
 
     if (mAlpha == alpha)
@@ -260,7 +263,7 @@ void Image::setAlpha(float alpha)
             if (!surface)
             {
                 if (mAlphaCache.size() > 100)
-                    cleanCache();
+                    SDLcleanCache();
 
                 mAlphaCache[mAlpha] = mSDLSurface;
             }
@@ -274,7 +277,7 @@ void Image::setAlpha(float alpha)
             }
             else
             {
-                mSDLSurface = Image::duplicateSurface(mSDLSurface);
+                mSDLSurface = Image::SDLduplicateSurface(mSDLSurface);
             }
         }
 
@@ -432,7 +435,7 @@ Image* Image::SDLgetScaledImage(int width, int height)
     return scaledImage;
 }
 
-SDL_Surface* Image::duplicateSurface(SDL_Surface* tmpImage)
+SDL_Surface* Image::SDLduplicateSurface(SDL_Surface* tmpImage)
 {
     if (!tmpImage || !tmpImage->format)
         return NULL;
@@ -629,9 +632,9 @@ Image *Image::getSubImage(int x, int y, int width, int height)
     return new SubImage(this, mSDLSurface, x, y, width, height);
 }
 
-void Image::terminateAlphaCache()
+void Image::SDLterminateAlphaCache()
 {
-    cleanCache();
+    SDLcleanCache();
     mUseAlphaCache = false;
 }
 
@@ -647,7 +650,7 @@ SubImage::SubImage(Image *parent, SDL_Surface *image,
     if (mParent)
     {
         mParent->incRef();
-        mParent->terminateAlphaCache();
+        mParent->SDLterminateAlphaCache();
         mHasAlphaChannel = mParent->hasAlphaChannel();
         mAlphaChannel = mParent->SDLgetAlphaChannel();
     }
diff --git a/src/resources/image.h b/src/resources/image.h
index 815b7764..1db52ca0 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -113,16 +113,10 @@ class Image : public Resource
         { return mBounds.h; }
 
         /**
-         * Tells if the image was loaded using OpenGL or SDL
+         * Tells if the system is using OpenGL or SDL
          * @return true if OpenGL, false if SDL.
          */
-        bool isAnOpenGLOne() const;
-
-        /**
-         * Tells if the image has got an alpha channel
-         * @return true if it's true, false otherwise.
-         */
-        bool hasAlphaChannel();
+        static bool useOpenGL();
 
         /**
          * Sets the alpha value of this image.
@@ -143,10 +137,24 @@ class Image : public Resource
          */
         virtual Image *getSubImage(int x, int y, int width, int height);
 
+        /**
+         * Tells if the image has got an alpha channel
+         * @return true if it's true, false otherwise.
+         */
+        bool hasAlphaChannel();
 
         // SDL only public functions
 
         /**
+         * Disable the transparency handling (for low CPUs in SDL Mode)
+         */
+        static void SDLdisableTransparency()
+        { mDisableTransparency = true; }
+
+        static bool SDLisTransparencyDisabled()
+        { return mDisableTransparency; }
+
+        /**
          * Gets an scaled instance of an image.
          *
          * @param width The desired width of the scaled image.
@@ -171,13 +179,13 @@ class Image : public Resource
         Uint8 *SDLgetAlphaChannel() const
         { return mAlphaChannel; }
 
-        SDL_Surface* duplicateSurface(SDL_Surface* tmpImage);
+        SDL_Surface* SDLduplicateSurface(SDL_Surface* tmpImage);
 
-        void cleanCache();
+        void SDLcleanCache();
 
-        void terminateAlphaCache();
+        void SDLterminateAlphaCache();
 
-        static void setEnableAlphaCache(bool n)
+        static void SDLsetEnableAlphaCache(bool n)
         { mEnableAlphaCache = n; }
 
 #ifdef USE_OPENGL
@@ -199,18 +207,17 @@ class Image : public Resource
 
     protected:
 
-      // -----------------------
-      // Generic protected members
-      // -----------------------
+        // -----------------------
+        // Generic protected members
+        // -----------------------
 
         SDL_Rect mBounds;
         bool mLoaded;
         float mAlpha;
-        bool mHasAlphaChannel;
 
-      // -----------------------
-      // SDL protected members
-      // -----------------------
+        // -----------------------
+        // SDL protected members
+        // -----------------------
 
         /** SDL Constructor */
         Image(SDL_Surface *image, bool hasAlphaChannel = false,
@@ -225,13 +232,18 @@ class Image : public Resource
 
         /** Alpha Channel pointer used for 32bit based SDL surfaces */
         Uint8 *mAlphaChannel;
+        bool mHasAlphaChannel;
 
+        /** Alpha cache: The cache stores a copy of the image
+            for specific requested opacities, hence, increasing
+            the image disply speed */
         std::map<float, SDL_Surface*> mAlphaCache;
-
         bool mUseAlphaCache;
-
         static bool mEnableAlphaCache;
 
+        /** Stores whether the transparency is disabled */
+        static bool mDisableTransparency;
+
         // -----------------------
         // OpenGL protected members
         // -----------------------