Made the wallpaper be rescaled when necessary under SDL and OpenGL.

The SDL methods to rescale the wallpaper has been optimized to permit rescaling
at load time while OpenGL draws directly rescaled. Does someone know how to smooth
the rescaled image under OpenGL?

6 files changed, 614 insertions, 1 deletions

diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index 0c542a8b..66f87ccb 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -26,6 +26,7 @@
 #include "log.h"
 
 #include <SDL_image.h>
+#include "resources/sdlrescalefacility.h"
 
 #ifdef USE_OPENGL
 bool Image::mUseOpenGL = false;
@@ -289,6 +290,15 @@ void Image::unload()
 #endif
 }
 
+bool Image::isAnOpenGLOne() const
+{
+#ifdef USE_OPENGL
+    return mUseOpenGL;
+#else
+    return false;
+#endif
+}
+
 Image *Image::getSubImage(int x, int y, int width, int height)
 {
     // Create a new clipped sub-image
@@ -395,6 +405,34 @@ float Image::getAlpha() const
     return mAlpha;
 }
 
+Image* Image::SDLgetScaledImage(unsigned int width, unsigned int height)
+{
+    // No scaling on incorrect new values.
+    if (width == 0 || height == 0)
+    return NULL;
+    
+    // No scaling when there is ... no different given size ...
+    if (width == getWidth() && height == getHeight())
+        return NULL;
+
+    Image* scaledImage = NULL;
+    SDL_Surface* scaledSurface = NULL;
+    
+    if (mImage)
+    {
+        scaledSurface = _SDLzoomSurface(mImage,
+                    (double) width / getWidth(),
+                    (double) height / getHeight(),
+                    1);
+
+        // The load function takes of the SDL<->OpenGL implementation
+        // and about freeing the given SDL_surface*.
+        if (scaledSurface)
+            scaledImage = load(scaledSurface);
+    }
+    return scaledImage;
+}
+
 #ifdef USE_OPENGL
 void Image::setLoadAsOpenGL(bool useOpenGL)
 {
@@ -469,4 +507,3 @@ Image *SubImage::getSubImage(int x, int y, int w, int h)
 {
     return mParent->getSubImage(mBounds.x + x, mBounds.y + y, w, h);
 }
-
diff --git a/src/resources/image.h b/src/resources/image.h
index 4422fcc8..dc06a5f3 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -88,6 +88,16 @@ class Image : public Resource
         static Image *load(SDL_Surface *);
 
         /**
+         * 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(unsigned int width, unsigned int height);
+
+        /**
          * Frees the resources created by SDL.
          */
         virtual void unload();
@@ -105,6 +115,12 @@ class Image : public Resource
         { return mBounds.h; }
 
         /**
+         * Tells if the image was loade using OpenGL or SDL
+         * @return true if OpenGL, false if SDL.
+         */
+        bool isAnOpenGLOne() const;
+
+        /**
          * Creates a new image with the desired clipping rectangle.
          *
          * @return <code>NULL</code> if creation failed and a valid
diff --git a/src/resources/resourcemanager.cpp b/src/resources/resourcemanager.cpp
index 0b8d6c35..bc3267da 100644
--- a/src/resources/resourcemanager.cpp
+++ b/src/resources/resourcemanager.cpp
@@ -214,6 +214,19 @@ std::string ResourceManager::getPath(const std::string &file)
     return path;
 }
 
+bool ResourceManager::addResource(const std::string &idPath,
+                                  Resource* resource)
+{
+    if (resource)
+    {
+        resource->incRef();
+        resource->mIdPath = idPath;
+        mResources[idPath] = resource;
+        return true;
+    }
+    return false;
+}
+
 Resource *ResourceManager::get(const std::string &idPath, generator fun,
                                void *data)
 {
diff --git a/src/resources/resourcemanager.h b/src/resources/resourcemanager.h
index b2ad3069..88fd60fc 100644
--- a/src/resources/resourcemanager.h
+++ b/src/resources/resourcemanager.h
@@ -125,6 +125,15 @@ class ResourceManager
         Resource *load(const std::string &path, loader fun);
 
         /**
+         * Adds a preformatted resource to the resource map.
+         *
+         * @param path The file name.
+         * @param Resource  The Resource to add.
+         * @return true if successfull, false otherwise.
+         */
+        bool addResource(const std::string &idPath, Resource* resource);
+
+        /**
         * Copies a file from one place to another (useful for extracting
         * raw files from a zip archive, for example)
         *
diff --git a/src/resources/sdlrescalefacility.cpp b/src/resources/sdlrescalefacility.cpp
new file mode 100644
index 00000000..cc478483
--- /dev/null
+++ b/src/resources/sdlrescalefacility.cpp
@@ -0,0 +1,486 @@
+/*
+ *  The Mana World
+ *  Copyright (C) 2004  The Mana World Development Team
+ *
+ *  This file is part of The Mana World.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the Low 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, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * 
+ *  Source code taken from:
+ *
+ * SDL_rotozoom - rotozoomer
+ * 
+ * LGPL (c) A. Schiffler
+ *
+ */ 
+
+#include "sdlrescalefacility.h"
+
+#define VALUE_LIMIT 0.001
+
+typedef struct tColorRGBA {
+Uint8 r;
+Uint8 g;
+Uint8 b;
+Uint8 a;
+} tColorRGBA;
+
+void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
+{
+    /*
+     * Sanity check zoom factors 
+     */
+    if (zoomx < VALUE_LIMIT) {
+    zoomx = VALUE_LIMIT;
+    }
+    if (zoomy < VALUE_LIMIT) {
+    zoomy = VALUE_LIMIT;
+    }
+
+    /*
+     * Calculate target size 
+     */
+    *dstwidth = (int) ((double) width * zoomx);
+    *dstheight = (int) ((double) height * zoomy);
+    if (*dstwidth < 1) {
+    *dstwidth = 1;
+    }
+    if (*dstheight < 1) {
+    *dstheight = 1;
+    }
+}
+
+int zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy, int smooth)
+{
+    int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, ex, ey, t1, t2, sstep, lx, ly;
+    tColorRGBA *c00, *c01, *c10, *c11, *cswap;
+    tColorRGBA *sp, *csp, *dp;
+    int dgap;
+
+    /*
+     * Variable setup 
+     */
+    if (smooth) {
+    /*
+     * For interpolation: assume source dimension is one pixel 
+     */
+    /*
+     * smaller to avoid overflow on right and bottom edge.     
+     */
+    sx = (int) (65536.0 * (float) (src->w - 1) / (float) dst->w);
+    sy = (int) (65536.0 * (float) (src->h - 1) / (float) dst->h);
+    } else {
+    sx = (int) (65536.0 * (float) src->w / (float) dst->w);
+    sy = (int) (65536.0 * (float) src->h / (float) dst->h);
+    }
+
+    /*
+     * Allocate memory for row increments 
+     */
+    if ((sax = (int *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
+    return (-1);
+    }
+    if ((say = (int *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
+    free(sax);
+    return (-1);
+    }
+
+    /*
+     * Precalculate row increments 
+     */
+    sp = csp = (tColorRGBA *) src->pixels;
+    dp = (tColorRGBA *) dst->pixels;
+
+    if (flipx) csp += (src->w-1);
+    if (flipy) csp += (src->pitch*(src->h-1));
+
+    csx = 0;
+    csax = sax;
+    for (x = 0; x <= dst->w; x++) {
+    *csax = csx;
+    csax++;
+    csx &= 0xffff;
+    csx += sx;
+    }
+    csy = 0;
+    csay = say;
+    for (y = 0; y <= dst->h; y++) {
+    *csay = csy;
+    csay++;
+    csy &= 0xffff;
+    csy += sy;
+    }
+
+    dgap = dst->pitch - dst->w * 4;
+
+    /*
+     * Switch between interpolating and non-interpolating code 
+     */
+    if (smooth) {
+
+    /*
+     * Interpolating Zoom 
+     */
+
+    /*
+     * Scan destination 
+     */
+    ly = 0;
+    csay = say;
+    for (y = 0; y < dst->h; y++) {
+            /*
+             * Setup color source pointers 
+             */
+            c00 = csp;      
+            c01 = csp;
+            c01++;      
+            c10 = (tColorRGBA *) ((Uint8 *) csp + src->pitch);
+            c11 = c10;
+            c11++;
+            csax = sax;
+            if (flipx) {
+         cswap = c00; c00=c01; c01=cswap;
+         cswap = c10; c10=c11; c11=cswap;
+            }
+            if (flipy) {
+         cswap = c00; c00=c10; c10=cswap;
+         cswap = c01; c01=c11; c11=cswap;
+            }
+            lx = 0;
+        for (x = 0; x < dst->w; x++) {
+        /*
+         * Interpolate colors 
+         */
+        ex = (*csax & 0xffff);
+        ey = (*csay & 0xffff);
+        t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff;
+        t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff;
+        dp->r = (((t2 - t1) * ey) >> 16) + t1;
+        t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff;
+        t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff;
+        dp->g = (((t2 - t1) * ey) >> 16) + t1;
+        t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff;
+        t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff;
+        dp->b = (((t2 - t1) * ey) >> 16) + t1;
+        t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff;
+        t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff;
+        dp->a = (((t2 - t1) * ey) >> 16) + t1;
+
+        /*
+         * Advance source pointers 
+         */
+        csax++;
+        sstep = (*csax >> 16);
+        lx += sstep;
+        if (lx >= src->w) sstep = 0;
+        if (flipx) sstep = -sstep;
+        c00 += sstep;
+        c01 += sstep;
+        c10 += sstep;
+        c11 += sstep;
+        /*
+         * Advance destination pointer 
+         */
+        dp++;
+        }
+        /*
+         * Advance source pointer 
+         */
+        csay++;
+        sstep = (*csay >> 16);
+            ly += sstep;
+            if (ly >= src->h) sstep = 0;
+            sstep *= src->pitch;
+        if (flipy) sstep = -sstep;
+        csp = (tColorRGBA *) ((Uint8 *) csp + sstep);
+
+        /*
+         * Advance destination pointers 
+         */
+        dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
+    }
+    } else {
+
+    /*
+     * Non-Interpolating Zoom 
+     */
+
+    csay = say;
+    for (y = 0; y < dst->h; y++) {
+        sp = csp;
+        csax = sax;
+        for (x = 0; x < dst->w; x++) {
+        /*
+         * Draw 
+         */
+        *dp = *sp;
+        /*
+         * Advance source pointers 
+         */
+        csax++;
+        sstep = (*csax >> 16);
+        if (flipx) sstep = -sstep;
+        sp += sstep;
+        /*
+         * Advance destination pointer 
+         */
+        dp++;
+        }
+        /*
+         * Advance source pointer 
+         */
+        csay++;
+        sstep = (*csay >> 16) * src->pitch;
+        if (flipy) sstep = -sstep;
+        csp = (tColorRGBA *) ((Uint8 *) csp + sstep);
+
+        /*
+         * Advance destination pointers 
+         */
+        dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
+    }
+    }
+
+    /*
+     * Remove temp arrays 
+     */
+    free(sax);
+    free(say);
+
+    return (0);
+}
+
+
+
+int zoomSurfaceY(SDL_Surface * src, SDL_Surface * dst, int flipx, int flipy)
+{
+    Uint32 x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, sstep;
+    Uint8 *sp, *dp, *csp;
+    int dgap;
+
+    /*
+     * Variable setup 
+     */
+    sx = (Uint32) (65536.0 * (float) src->w / (float) dst->w);
+    sy = (Uint32) (65536.0 * (float) src->h / (float) dst->h);
+
+ 
+     /*
+     * Allocate memory for row increments 
+     */
+    if ((sax = (Uint32 *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
+    return (-1);
+    }
+    if ((say = (Uint32 *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
+    free(sax);
+    return (-1);
+    }
+
+    /*
+     * Pointer setup 
+     */
+    sp = csp = (Uint8 *) src->pixels;
+    dp = (Uint8 *) dst->pixels;
+    dgap = dst->pitch - dst->w;
+
+    if (flipx) csp += (src->w-1);
+    if (flipy) csp  = ( (Uint8*)csp + src->pitch*(src->h-1) );
+
+    /*
+     * Precalculate row increments 
+     */
+    csx = 0;
+    csax = sax;
+    for (x = 0; x <= dst->w; x++) {
+    *csax = csx;
+    csax++;
+    csx &= 0xffff;
+    csx += sx;
+    }
+    csy = 0;
+    csay = say;
+    for (y = 0; y <= dst->h; y++) {
+    *csay = csy;
+    csay++;
+    csy &= 0xffff;
+    csy += sy;
+    }
+
+
+    /*
+     * Draw 
+     */
+    csay = say;
+    for (y = 0; y < dst->h; y++) {
+    csax = sax;
+    sp = csp;
+    for (x = 0; x < dst->w; x++) {
+        /*
+         * Draw 
+         */
+        *dp = *sp;
+        /*
+         * Advance source pointers 
+         */
+        csax++;
+            sstep = (*csax >> 16);
+            if (flipx) sstep = -sstep;
+            sp += sstep;
+        /*
+         * Advance destination pointer 
+         */
+        dp++;
+    }
+    /*
+     * Advance source pointer (for row) 
+     */
+    csay++;
+        sstep = (*csay >> 16) * src->pitch;
+        if (flipy) sstep = -sstep;
+        csp = ((Uint8 *) csp + sstep);
+
+    /*
+     * Advance destination pointers 
+     */
+    dp += dgap;
+    }
+
+    /*
+     * Remove temp arrays 
+     */
+    free(sax);
+    free(say);
+
+    return (0);
+}
+
+
+
+SDL_Surface *_SDLzoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth)
+{
+    SDL_Surface *rz_src;
+    SDL_Surface *rz_dst;
+    int dstwidth, dstheight;
+    int is32bit;
+    int i, src_converted;
+    int flipx, flipy;
+
+    /*
+     * Sanity check 
+     */
+    if (src == NULL)
+    return (NULL);
+
+    /*
+     * Determine if source surface is 32bit or 8bit 
+     */
+    is32bit = (src->format->BitsPerPixel == 32);
+    if ((is32bit) || (src->format->BitsPerPixel == 8)) {
+    /*
+     * Use source surface 'as is' 
+     */
+    rz_src = src;
+    src_converted = 0;
+    } else {
+    /*
+     * New source surface is 32bit with a defined RGBA ordering 
+     */
+    rz_src =
+        SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+                                0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
+#else
+                                0xff000000,  0x00ff0000, 0x0000ff00, 0x000000ff
+#endif
+        );
+    SDL_BlitSurface(src, NULL, rz_src, NULL);
+    src_converted = 1;
+    is32bit = 1;
+    }
+
+    flipx = (zoomx<0.0);
+    if (flipx) zoomx = -zoomx;
+    flipy = (zoomy<0.0);
+    if (flipy) zoomy = -zoomy;
+
+    /* Get size if target */
+    zoomSurfaceSize(rz_src->w, rz_src->h, zoomx, zoomy, &dstwidth, &dstheight);
+
+    /*
+     * Alloc space to completely contain the zoomed surface 
+     */
+    rz_dst = NULL;
+    if (is32bit) {
+    /*
+     * Target surface is 32bit with source RGBA/ABGR ordering 
+     */
+    rz_dst =
+        SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
+                 rz_src->format->Rmask, rz_src->format->Gmask,
+                 rz_src->format->Bmask, rz_src->format->Amask);
+    } else {
+    /*
+     * Target surface is 8bit 
+     */
+    rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
+    }
+
+    /*
+     * Lock source surface 
+     */
+    SDL_LockSurface(rz_src);
+    /*
+     * Check which kind of surface we have 
+     */
+    if (is32bit) {
+    /*
+     * Call the 32bit transformation routine to do the zooming (using alpha) 
+     */
+    zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy, smooth);
+    /*
+     * Turn on source-alpha support 
+     */
+    SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
+    } else {
+    /*
+     * Copy palette and colorkey info 
+     */
+    for (i = 0; i < rz_src->format->palette->ncolors; i++) {
+        rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
+    }
+    rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
+    /*
+     * Call the 8bit transformation routine to do the zooming 
+     */
+    zoomSurfaceY(rz_src, rz_dst, flipx, flipy);
+    SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
+    }
+    /*
+     * Unlock source surface 
+     */
+    SDL_UnlockSurface(rz_src);
+
+    /*
+     * Cleanup temp surface 
+     */
+    if (src_converted) {
+    SDL_FreeSurface(rz_src);
+    }
+
+    /*
+     * Return destination surface 
+     */
+    return (rz_dst);
+} 
diff --git a/src/resources/sdlrescalefacility.h b/src/resources/sdlrescalefacility.h
new file mode 100644
index 00000000..597e6933
--- /dev/null
+++ b/src/resources/sdlrescalefacility.h
@@ -0,0 +1,52 @@
+/*
+ *  The Mana World
+ *  Copyright (C) 2004  The Mana World Development Team
+ *
+ *  This file is part of The Mana World.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the Low 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, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * 
+ *  Source code taken from:
+ *
+ * SDL_rotozoom - rotozoomer
+ * 
+ * LGPL (c) A. Schiffler
+ *
+ */ 
+
+#ifndef SDLRESCALEFACILITY_H
+#define SDLRESCALEFACILITY_H
+
+#include <SDL.h>
+#include "image.h"
+
+/**
+ * _SDLzoomSurface is internally used by Image::getScaledImage() to provide
+ * a rescaled copy of its internal mImage member.
+ *
+ * @see Image::getScaledImage() for more details
+ *
+ * @param src the original surface to rescale
+ * @param zoomx the zoom factor used to rescale the surface horizontally. 1.0 doesn't rescale.
+ * A value lesser than 1.O shrink the image.
+ * @param zoomy the zoom factor used to rescale the surface vertically.
+ * @param smooth transform the scaled surface into a 32bit aliased image to smooth the rescaling.
+ *
+ * @return SDL_Surface The rescaled surface.
+ */
+
+SDL_Surface *_SDLzoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth);
+
+#endif
\ No newline at end of file