Revert part of eb49009d023e6e3b5d59a97b8fb5fed5eee83296 (#5230)

[oweals/minetest.git] / src / guiscalingfilter.cpp

diff --git a/src/guiscalingfilter.cpp b/src/guiscalingfilter.cpp
index 92dadeaec6c75351695b89df9dd7f700250cc245..41cc7283659ce2fa74058bb6bdc8c5dc4f80b273 100644 (file)
--- a/src/guiscalingfilter.cpp
+++ b/src/guiscalingfilter.cpp
@@ -19,7 +19,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "guiscalingfilter.h"
 #include "imagefilters.h"
 #include "settings.h"
-#include "main.h"              // for g_settings
 #include "util/numeric.h"
 #include <stdio.h>
 
@@ -28,54 +27,59 @@ with this program; if not, write to the Free Software Foundation, Inc.,
  * converting textures back into images repeatedly, and some don't even
  * allow it at all.
  */
-std::map<io::path, video::IImage *> imgCache;
+std::map<io::path, video::IImage *> g_imgCache;
 
 /* Maintain a static cache of all pre-scaled textures.  These need to be
  * cleared as well when the cached images.
  */
-std::map<io::path, video::ITexture *> txrCache;
+std::map<io::path, video::ITexture *> g_txrCache;
 
 /* Manually insert an image into the cache, useful to avoid texture-to-image
  * conversion whenever we can intercept it.
  */
-void guiScalingCache(io::path key, video::IVideoDriver *driver, video::IImage *value) {
+void guiScalingCache(io::path key, video::IVideoDriver *driver, video::IImage *value)
+{
        if (!g_settings->getBool("gui_scaling_filter"))
                return;
        video::IImage *copied = driver->createImage(value->getColorFormat(),
                        value->getDimension());
        value->copyTo(copied);
-       imgCache[key] = copied;
+       g_imgCache[key] = copied;
 }
 
 // Manually clear the cache, e.g. when switching to different worlds.
-void guiScalingCacheClear(video::IVideoDriver *driver) {
-       for (std::map<io::path, video::IImage *>::iterator it = imgCache.begin();
-                       it != imgCache.end(); it++) {
+void guiScalingCacheClear(video::IVideoDriver *driver)
+{
+       for (std::map<io::path, video::IImage *>::iterator it = g_imgCache.begin();
+                       it != g_imgCache.end(); ++it) {
                if (it->second != NULL)
                        it->second->drop();
        }
-       imgCache.clear();
-       for (std::map<io::path, video::ITexture *>::iterator it = txrCache.begin();
-                       it != txrCache.end(); it++) {
+       g_imgCache.clear();
+       for (std::map<io::path, video::ITexture *>::iterator it = g_txrCache.begin();
+                       it != g_txrCache.end(); ++it) {
                if (it->second != NULL)
                        driver->removeTexture(it->second);
        }
-       txrCache.clear();
+       g_txrCache.clear();
 }
 
 /* Get a cached, high-quality pre-scaled texture for display purposes.  If the
  * texture is not already cached, attempt to create it.  Returns a pre-scaled texture,
  * or the original texture if unable to pre-scale it.
  */
-video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver, video::ITexture *src,
-               const core::rect<s32> &srcrect, const core::rect<s32> &destrect) {
-
+video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver,
+               video::ITexture *src, const core::rect<s32> &srcrect,
+               const core::rect<s32> &destrect)
+{
+       if (src == NULL)
+               return src;
        if (!g_settings->getBool("gui_scaling_filter"))
                return src;
 
        // Calculate scaled texture name.
        char rectstr[200];
-       sprintf(rectstr, "%d:%d:%d:%d:%d:%d",
+       snprintf(rectstr, sizeof(rectstr), "%d:%d:%d:%d:%d:%d",
                srcrect.UpperLeftCorner.X,
                srcrect.UpperLeftCorner.Y,
                srcrect.getWidth(),
@@ -86,20 +90,20 @@ video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver, video::ITex
        io::path scalename = origname + "@guiScalingFilter:" + rectstr;
 
        // Search for existing scaled texture.
-       video::ITexture *scaled = txrCache[scalename];
+       video::ITexture *scaled = g_txrCache[scalename];
        if (scaled)
                return scaled;
 
        // Try to find the texture converted to an image in the cache.
        // If the image was not found, try to extract it from the texture.
-       video::IImage* srcimg = imgCache[origname];
+       video::IImage* srcimg = g_imgCache[origname];
        if (srcimg == NULL) {
                if (!g_settings->getBool("gui_scaling_filter_txr2img"))
                        return src;
                srcimg = driver->createImageFromData(src->getColorFormat(),
                        src->getSize(), src->lock(), false);
                src->unlock();
-               imgCache[origname] = srcimg;
+               g_imgCache[origname] = srcimg;
        }
 
        // Create a new destination image and scale the source into it.
@@ -125,7 +129,7 @@ video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver, video::ITex
        // Convert the scaled image back into a texture.
        scaled = driver->addTexture(scalename, destimg, NULL);
        destimg->drop();
-       txrCache[scalename] = scaled;
+       g_txrCache[scalename] = scaled;
 
        return scaled;
 }
@@ -133,8 +137,11 @@ video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver, video::ITex
 /* Convenience wrapper for guiScalingResizeCached that accepts parameters that
  * are available at GUI imagebutton creation time.
  */
-video::ITexture *guiScalingImageButton(video::IVideoDriver *driver, video::ITexture *src,
-               s32 width, s32 height) {
+video::ITexture *guiScalingImageButton(video::IVideoDriver *driver,
+               video::ITexture *src, s32 width, s32 height)
+{
+       if (src == NULL)
+               return src;
        return guiScalingResizeCached(driver, src,
                core::rect<s32>(0, 0, src->getSize().Width, src->getSize().Height),
                core::rect<s32>(0, 0, width, height));
@@ -146,10 +153,12 @@ video::ITexture *guiScalingImageButton(video::IVideoDriver *driver, video::IText
 void draw2DImageFilterScaled(video::IVideoDriver *driver, video::ITexture *txr,
                const core::rect<s32> &destrect, const core::rect<s32> &srcrect,
                const core::rect<s32> *cliprect, const video::SColor *const colors,
-               bool usealpha) {
-
+               bool usealpha)
+{
        // Attempt to pre-scale image in software in high quality.
        video::ITexture *scaled = guiScalingResizeCached(driver, txr, srcrect, destrect);
+       if (scaled == NULL)
+               return;
 
        // Correct source rect based on scaled image.
        const core::rect<s32> mysrcrect = (scaled != txr)