Move image class into image directory.

2 files changed, 746 insertions, 0 deletions

diff --git a/src/resources/image/image.cpp b/src/resources/image/image.cpp
new file mode 100644
index 000000000..683129e7a
--- /dev/null
+++ b/src/resources/image/image.cpp
@@ -0,0 +1,499 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2016  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/image/image.h"
+
+#include "logger.h"
+
+#ifdef USE_OPENGL
+#include "resources/openglimagehelper.h"
+#endif  // USE_OPENGL
+
+#include "resources/memorymanager.h"
+#include "resources/sdlimagehelper.h"
+#include "resources/subimage.h"
+
+#include "resources/resourcemanager/resourcemanager.h"
+
+#include "utils/sdlcheckutils.h"
+
+#ifdef USE_SDL2
+#include <SDL2_rotozoom.h>
+#else  // USE_SDL2
+#include <SDL_rotozoom.h>
+#endif  // USE_SDL2
+
+#include "debug.h"
+
+#ifdef USE_SDL2
+Image::Image(SDL_Texture *restrict const image,
+             const int width, const int height) :
+    Resource(),
+#ifdef USE_OPENGL
+    mGLImage(0),
+    mTexWidth(0),
+    mTexHeight(0),
+#endif
+    mBounds(),
+    mAlpha(1.0F),
+    mSDLSurface(nullptr),
+    mTexture(image),
+    mAlphaChannel(nullptr),
+    mAlphaCache(),
+    mLoaded(false),
+    mHasAlphaChannel(false),
+    mUseAlphaCache(false),
+    mIsAlphaVisible(true),
+    mIsAlphaCalculated(false)
+{
+#ifdef DEBUG_IMAGES
+    logger->log("created image: %p", this);
+#endif
+
+    mBounds.x = 0;
+    mBounds.y = 0;
+
+    if (mTexture)
+    {
+        mBounds.w = CAST_U16(width);
+        mBounds.h = CAST_U16(height);
+
+        mLoaded = true;
+    }
+    else
+    {
+        logger->log("Image::Image(SDL_Texture *const image):"
+            " Couldn't load invalid Surface!");
+        mBounds.w = 0;
+        mBounds.h = 0;
+    }
+}
+#endif
+
+Image::Image(SDL_Surface *restrict const image, const bool hasAlphaChannel0,
+             uint8_t *restrict const alphaChannel) :
+    Resource(),
+#ifdef USE_OPENGL
+    mGLImage(0),
+    mTexWidth(0),
+    mTexHeight(0),
+#endif
+    mBounds(),
+    mAlpha(1.0F),
+    mSDLSurface(image),
+#ifdef USE_SDL2
+    mTexture(nullptr),
+#endif
+    mAlphaChannel(alphaChannel),
+    mAlphaCache(),
+    mLoaded(false),
+    mHasAlphaChannel(hasAlphaChannel0),
+    mUseAlphaCache(SDLImageHelper::mEnableAlphaCache),
+    mIsAlphaVisible(hasAlphaChannel0),
+    mIsAlphaCalculated(false)
+{
+#ifdef DEBUG_IMAGES
+    logger->log("created image: %p", static_cast<void*>(this));
+#endif
+
+    mBounds.x = 0;
+    mBounds.y = 0;
+
+    if (mSDLSurface)
+    {
+        mBounds.w = CAST_U16(mSDLSurface->w);
+        mBounds.h = CAST_U16(mSDLSurface->h);
+
+        mLoaded = true;
+    }
+    else
+    {
+        logger->log(
+          "Image::Image(SDL_Surface*): Couldn't load invalid Surface!");
+        mBounds.w = 0;
+        mBounds.h = 0;
+    }
+}
+
+#ifdef USE_OPENGL
+Image::Image(const GLuint glimage, const int width, const int height,
+             const int texWidth, const int texHeight) :
+    Resource(),
+    mGLImage(glimage),
+    mTexWidth(texWidth),
+    mTexHeight(texHeight),
+    mBounds(),
+    mAlpha(1.0F),
+    mSDLSurface(nullptr),
+#ifdef USE_SDL2
+    mTexture(nullptr),
+#endif
+    mAlphaChannel(nullptr),
+    mAlphaCache(),
+    mLoaded(false),
+    mHasAlphaChannel(true),
+    mUseAlphaCache(false),
+    mIsAlphaVisible(true),
+    mIsAlphaCalculated(false)
+{
+#ifdef DEBUG_IMAGES
+    logger->log("created image: %p", static_cast<void*>(this));
+#endif
+
+    mBounds.x = 0;
+    mBounds.y = 0;
+    mBounds.w = CAST_U16(width);
+    mBounds.h = CAST_U16(height);
+
+    if (mGLImage)
+    {
+        mLoaded = true;
+    }
+    else
+    {
+        logger->log("Image::Image(GLuint*, ...):"
+            " Couldn't load invalid Surface!");
+    }
+}
+#endif
+
+Image::~Image()
+{
+#ifdef DEBUG_IMAGES
+    logger->log("delete image: %p", static_cast<void*>(this));
+    logger->log("  %s, %s", mIdPath.c_str(), mSource.c_str());
+#endif
+    unload();
+}
+
+void Image::SDLCleanCache()
+{
+    for (std::map<float, SDL_Surface*>::iterator
+         i = mAlphaCache.begin(), i_end = mAlphaCache.end();
+         i != i_end; ++i)
+    {
+        if (mSDLSurface != i->second)
+            resourceManager->scheduleDelete(i->second);
+        i->second = nullptr;
+    }
+    mAlphaCache.clear();
+}
+
+void Image::unload()
+{
+    mLoaded = false;
+
+    if (mSDLSurface)
+    {
+        SDLCleanCache();
+        // Free the image surface.
+        MSDL_FreeSurface(mSDLSurface);
+        mSDLSurface = nullptr;
+
+        delete [] mAlphaChannel;
+        mAlphaChannel = nullptr;
+    }
+#ifdef USE_SDL2
+    if (mTexture)
+    {
+        SDL_DestroyTexture(mTexture);
+        mTexture = nullptr;
+    }
+#endif
+
+#ifdef USE_OPENGL
+    if (mGLImage)
+    {
+        glDeleteTextures(1, &mGLImage);
+        mGLImage = 0;
+#ifdef DEBUG_OPENGL_LEAKS
+        if (textures_count > 0)
+            textures_count --;
+#endif
+    }
+#endif
+}
+
+bool Image::hasAlphaChannel() const
+{
+    if (mLoaded)
+        return mHasAlphaChannel;
+
+#ifdef USE_OPENGL
+    if (OpenGLImageHelper::mUseOpenGL != RENDER_SOFTWARE)
+        return true;
+#endif
+
+    return false;
+}
+
+SDL_Surface *Image::getByAlpha(const float alpha)
+{
+    const std::map<float, SDL_Surface*>::const_iterator
+        it = mAlphaCache.find(alpha);
+    if (it != mAlphaCache.end())
+        return (*it).second;
+    return nullptr;
+}
+
+void Image::setAlpha(const float alpha)
+{
+    if (mAlpha == alpha || !ImageHelper::mEnableAlpha)
+        return;
+
+    if (alpha < 0.0F || alpha > 1.0F)
+        return;
+
+    if (mSDLSurface)
+    {
+        if (mUseAlphaCache)
+        {
+            SDL_Surface *surface = getByAlpha(mAlpha);
+            if (!surface)
+            {
+                if (mAlphaCache.size() > 100)
+                {
+#ifdef DEBUG_ALPHA_CACHE
+                    logger->log("cleanCache");
+                    for (std::map<float, SDL_Surface*>::const_iterator
+                         i = mAlphaCache.begin(), i_end = mAlphaCache.end();
+                         i != i_end; ++i)
+                    {
+                        logger->log("alpha: " + toString(i->first));
+                    }
+#endif
+                    SDLCleanCache();
+                }
+                surface = mSDLSurface;
+                if (surface)
+                    mAlphaCache[mAlpha] = surface;
+            }
+            else
+            {
+                logger->log("cache bug");
+            }
+
+            surface = getByAlpha(alpha);
+            if (surface)
+            {
+                if (mSDLSurface == surface)
+                    logger->log("bug");
+                mAlphaCache.erase(alpha);
+                mSDLSurface = surface;
+                mAlpha = alpha;
+                return;
+            }
+            else
+            {
+                mSDLSurface = SDLImageHelper::SDLDuplicateSurface(mSDLSurface);
+                if (!mSDLSurface)
+                    return;
+            }
+        }
+
+        mAlpha = alpha;
+
+        if (!mHasAlphaChannel)
+        {
+#ifdef USE_SDL2
+            SDL_SetSurfaceAlphaMod(mSDLSurface,
+                CAST_U8(255 * mAlpha));
+#else
+            // Set the alpha value this image is drawn at
+            SDL_SetAlpha(mSDLSurface, SDL_SRCALPHA,
+                CAST_U8(255 * mAlpha));
+#endif
+        }
+        else
+        {
+            if (SDL_MUSTLOCK(mSDLSurface))
+                SDL_LockSurface(mSDLSurface);
+
+            const int bx = mBounds.x;
+            const int by = mBounds.y;
+            const int bw = mBounds.w;
+            const int bh = mBounds.h;
+            const int bxw = bx + bw;
+            const int sw = mSDLSurface->w;
+            const int maxHeight = std::min(by + bh, mSDLSurface->h);
+            const int maxWidth = std::min(bxw, sw);
+            const int i1 = by * sw + bx;
+            const SDL_PixelFormat * const fmt = mSDLSurface->format;
+            const uint32_t amask = fmt->Amask;
+            const uint32_t invMask = ~fmt->Amask;
+            const uint8_t aloss = fmt->Aloss;
+            const uint8_t ashift = fmt->Ashift;
+
+            if (!bx && bxw == sw)
+            {
+                const int i2 = (maxHeight - 1) * sw + maxWidth - 1;
+                for (int i = i1; i <= i2; i++)
+                {
+                    const uint8_t sourceAlpha = mAlphaChannel[i];
+                    if (sourceAlpha > 0)
+                    {
+                        const uint8_t a = CAST_U8(
+                            static_cast<float>(sourceAlpha) * mAlpha);
+
+                        uint32_t c = (static_cast<uint32_t*>(
+                            mSDLSurface->pixels))[i];
+                        c &= invMask;
+                        c |= ((a >> aloss) << ashift & amask);
+                        (static_cast<uint32_t*>(mSDLSurface->pixels))[i] = c;
+                    }
+                }
+            }
+            else
+            {
+                for (int y = by; y < maxHeight; y ++)
+                {
+                    const int idx = y * sw;
+                    const int x1 = idx + bx;
+                    const int x2 = idx + maxWidth;
+                    for (int i = x1; i < x2; i ++)
+                    {
+                        const uint8_t sourceAlpha = mAlphaChannel[i];
+                        if (sourceAlpha > 0)
+                        {
+                            const uint8_t a = CAST_U8(
+                                static_cast<float>(sourceAlpha) * mAlpha);
+
+                            uint32_t c = (static_cast<uint32_t*>(
+                                mSDLSurface->pixels))[i];
+                            c &= invMask;
+                            c |= ((a >> aloss) << ashift & amask);
+                            (static_cast<uint32_t*>(
+                                mSDLSurface->pixels))[i] = c;
+                        }
+                    }
+                }
+            }
+
+            if (SDL_MUSTLOCK(mSDLSurface))
+                SDL_UnlockSurface(mSDLSurface);
+        }
+    }
+#ifdef USE_SDL2
+    else if (mTexture)
+    {
+        mAlpha = alpha;
+        SDL_SetTextureAlphaMod(mTexture,
+            CAST_U8(255 * mAlpha));
+    }
+#endif
+    else
+    {
+        mAlpha = alpha;
+    }
+}
+
+Image* Image::SDLgetScaledImage(const int width, const int height) const
+{
+    // No scaling on incorrect new values.
+    if (width == 0 || height == 0)
+        return nullptr;
+
+    // No scaling when there is ... no different given size ...
+    if (width == mBounds.w && height == mBounds.h)
+        return nullptr;
+
+    Image* scaledImage = nullptr;
+
+    if (mSDLSurface)
+    {
+        SDL_Surface *const scaledSurface = zoomSurface(mSDLSurface,
+                    static_cast<double>(width) / mBounds.w,
+                    static_cast<double>(height) / mBounds.h,
+                    1);
+
+        // The load function takes care of the SDL<->OpenGL implementation
+        // and about freeing the given SDL_surface*.
+        if (scaledSurface)
+        {
+            scaledImage = imageHelper->loadSurface(scaledSurface);
+            MSDL_FreeSurface(scaledSurface);
+        }
+    }
+    return scaledImage;
+}
+
+Image *Image::getSubImage(const int x, const int y,
+                          const int width, const int height)
+{
+    // Create a new clipped sub-image
+#ifdef USE_OPENGL
+    const RenderType mode = OpenGLImageHelper::mUseOpenGL;
+    if (mode == RENDER_NORMAL_OPENGL ||
+        mode == RENDER_SAFE_OPENGL ||
+        mode == RENDER_GLES_OPENGL ||
+        mode == RENDER_GLES2_OPENGL ||
+        mode == RENDER_MODERN_OPENGL)
+    {
+        return new SubImage(this,
+            mGLImage,
+            x, y,
+            width, height,
+            mTexWidth, mTexHeight);
+    }
+#endif
+
+#ifdef USE_SDL2
+#ifndef USE_OPENGL
+    const RenderType mode = ImageHelper::mUseOpenGL;
+#endif
+    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
+}
+
+void Image::SDLTerminateAlphaCache()
+{
+    SDLCleanCache();
+    mUseAlphaCache = false;
+}
+
+int Image::calcMemoryLocal() const
+{
+    // +++ this calculation can be wrong for SDL2
+    int sz = static_cast<int>(sizeof(Image) +
+        sizeof(std::map<float, SDL_Surface*>)) +
+        Resource::calcMemoryLocal();
+    if (mSDLSurface)
+    {
+        sz += CAST_S32(mAlphaCache.size()) *
+            memoryManager.getSurfaceSize(mSDLSurface);
+    }
+    return sz;
+}
+
+#ifdef USE_OPENGL
+void Image::decRef()
+{
+    if (mGLImage && getRefCount() <= 1)
+        OpenGLImageHelper::invalidate(mGLImage);
+    Resource::decRef();
+}
+#endif
diff --git a/src/resources/image/image.h b/src/resources/image/image.h
new file mode 100644
index 000000000..39492c360
--- /dev/null
+++ b/src/resources/image/image.h
@@ -0,0 +1,247 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2016  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_IMAGE_H
+#define RESOURCES_IMAGE_H
+
+#include "localconsts.h"
+
+#include "enums/resources/imagetype.h"
+
+#include "resources/resource.h"
+
+#include <SDL_video.h>
+
+#ifdef USE_OPENGL
+
+#ifdef ANDROID
+#include <GLES/gl.h>
+#else
+#ifndef USE_SDL2
+#define GL_GLEXT_PROTOTYPES 1
+#endif
+#include <SDL_opengl.h>
+#endif
+#endif
+
+#ifdef USE_SDL2
+#include <SDL_render.h>
+#endif
+
+#include <map>
+
+/**
+ * Defines a class for loading and storing images.
+ */
+class Image notfinal : public Resource
+{
+    friend class CompoundSprite;
+    friend class Graphics;
+    friend class ImageHelper;
+    friend class SDLGraphics;
+    friend class SDLImageHelper;
+    friend class SurfaceGraphics;
+#ifdef USE_SDL2
+    friend class SDL2SoftwareGraphics;
+    friend class SDL2SoftwareImageHelper;
+    friend class SurfaceImageHelper;
+#endif
+    friend class TestLauncher;
+#ifdef USE_OPENGL
+    friend class AtlasManager;
+    friend class MobileOpenGL2Graphics;
+    friend class MobileOpenGLGraphics;
+    friend class ModernOpenGLGraphics;
+    friend class NormalOpenGLGraphics;
+    friend class NullOpenGLGraphics;
+    friend class SafeOpenGLGraphics;
+    friend class OpenGLImageHelper;
+#ifndef ANDROID
+    friend class SafeOpenGLImageHelper;
+#endif  // ANDROID
+#endif  // USE_OPENGL
+
+    public:
+        A_DELETE_COPY(Image)
+
+        /**
+         * Destructor.
+         */
+        virtual ~Image();
+
+        /**
+         * Frees the resources created by SDL.
+         */
+        void unload();
+
+        /**
+         * Tells is the image is loaded
+         */
+        bool isLoaded() const A_WARN_UNUSED
+        { return mLoaded; }
+
+        /**
+         * Returns the width of the image.
+         */
+        inline int getWidth() const A_WARN_UNUSED A_INLINE
+        { return mBounds.w; }
+
+        /**
+         * Returns the height of the image.
+         */
+        inline int getHeight() const A_WARN_UNUSED A_INLINE
+        { return mBounds.h; }
+
+        /**
+         * Tells if the image has got an alpha channel
+         * @return true if it's true, false otherwise.
+         */
+        bool hasAlphaChannel() const A_WARN_UNUSED;
+
+        /**
+         * Sets the alpha value of this image.
+         */
+        virtual void setAlpha(const float alpha);
+
+        /**
+         * Creates a new image with the desired clipping rectangle.
+         *
+         * @return <code>NULL</code> if creation failed and a valid
+         *         object otherwise.
+         */
+        virtual Image *getSubImage(const int x, const int y,
+                                   const int width,
+                                   const int height) A_WARN_UNUSED;
+
+
+        // SDL only public functions
+
+        /**
+         * Gets an scaled instance of an image.
+         *
+         * @param width The desired width of the scaled image.
+         * @param height The desired height of the scaled image.
+         *
+         * @return A new Image* object.
+         */
+        Image* SDLgetScaledImage(const int width,
+                                 const int height) const A_WARN_UNUSED;
+
+        /**
+         * Get the alpha Channel of a SDL surface.
+         */
+        uint8_t *SDLgetAlphaChannel() const A_WARN_UNUSED
+        { return mAlphaChannel; }
+
+        void SDLCleanCache();
+
+        void SDLTerminateAlphaCache();
+
+#ifdef USE_OPENGL
+        int getTextureWidth() const A_WARN_UNUSED
+        { return mTexWidth; }
+
+        int getTextureHeight() const A_WARN_UNUSED
+        { return mTexHeight; }
+
+        GLuint getGLImage() const A_WARN_UNUSED
+        { return mGLImage; }
+
+        void decRef() override;
+
+        GLuint mGLImage;
+        int mTexWidth;
+        int mTexHeight;
+#endif
+
+        bool isHasAlphaChannel() const A_WARN_UNUSED
+        { return mHasAlphaChannel; }
+
+        bool isAlphaVisible() const A_WARN_UNUSED
+        { return mIsAlphaVisible; }
+
+        void setAlphaVisible(const bool b)
+        { mIsAlphaVisible = b; }
+
+        bool isAlphaCalculated() const A_WARN_UNUSED
+        { return mIsAlphaCalculated; }
+
+        void setAlphaCalculated(const bool b)
+        { mIsAlphaCalculated = b; }
+
+        SDL_Surface* getSDLSurface()
+        { return mSDLSurface; }
+
+        int calcMemoryLocal() const override;
+
+        virtual ImageTypeT getType() const
+        { return ImageType::Image; }
+
+        SDL_Rect mBounds;
+
+        float mAlpha;
+
+    protected:
+        // -----------------------
+        // SDL protected members
+        // -----------------------
+
+        /** SDL Constructor */
+        Image(SDL_Surface *restrict const image, const bool hasAlphaChannel,
+              uint8_t *restrict const alphaChannel = nullptr);
+
+#ifdef USE_SDL2
+        Image(SDL_Texture *restrict const image,
+              const int width, const int height);
+#endif
+
+        SDL_Surface *getByAlpha(const float alpha) A_WARN_UNUSED;
+
+        SDL_Surface *mSDLSurface;
+#ifdef USE_SDL2
+        SDL_Texture *mTexture;
+#endif
+
+        /** Alpha Channel pointer used for 32bit based SDL surfaces */
+        uint8_t *mAlphaChannel;
+
+        std::map<float, SDL_Surface*> mAlphaCache;
+
+        bool mLoaded;
+        bool mHasAlphaChannel;
+        bool mUseAlphaCache;
+        bool mIsAlphaVisible;
+        bool mIsAlphaCalculated;
+
+        // -----------------------
+        // OpenGL protected members
+        // -----------------------
+#ifdef USE_OPENGL
+        /**
+         * OpenGL Constructor.
+         */
+        Image(const GLuint glimage, const int width, const int height,
+              const int texWidth, const int texHeight);
+#endif
+};
+
+#endif  // RESOURCES_IMAGE_H