Fix some minor details from 6d61375

diff --git a/minetest.conf.example b/minetest.conf.example
index d9c3eb61ca490de05c620d7f62d155555e653c0d..4359879faa936813c06229aa17d9b60533a99865 100644 (file)
--- a/minetest.conf.example
+++ b/minetest.conf.example
@@ -177,9 +177,9 @@
 #    pixels when scaling down, at the cost of blurring some
 #    edge pixels when images are scaled by non-integer sizes.
 #gui_scaling_filter = false
-#    When gui_scaling_filter = true, all GUI images need to be
+#    When gui_scaling_filter is true, all GUI images need to be
 #    filtered in software, but some images are generated directly
-#    to hardare (e.g. render-to-texture for nodes in inventory).
+#    to hardware (e.g. render-to-texture for nodes in inventory).
 #    When gui_scaling_filter_txr2img is true, copy those images
 #    from hardware to software for scaling.  When false, fall back
 #    to the old scaling method, for video drivers that don't

diff --git a/src/guiFormSpecMenu.cpp b/src/guiFormSpecMenu.cpp
index 56729846e82c3988210d5a00c7692f8b9750026d..c29e74f7a2807b61b99405e7285308f0a6074335 100644 (file)
--- a/src/guiFormSpecMenu.cpp
+++ b/src/guiFormSpecMenu.cpp
@@ -1308,8 +1308,10 @@ void GUIFormSpecMenu::parseImageButton(parserData* data,std::string element,
                }
 
                e->setUseAlphaChannel(true);
-               e->setImage(guiScalingImageButton(Environment->getVideoDriver(), texture, geom.X, geom.Y));
-               e->setPressedImage(guiScalingImageButton(Environment->getVideoDriver(), pressed_texture, geom.X, geom.Y));
+               e->setImage(guiScalingImageButton(
+                       Environment->getVideoDriver(), texture, geom.X, geom.Y));
+               e->setPressedImage(guiScalingImageButton(
+                       Environment->getVideoDriver(), pressed_texture, geom.X, geom.Y));
                e->setScaleImage(true);
                e->setNotClipped(noclip);
                e->setDrawBorder(drawborder);

diff --git a/src/guiscalingfilter.cpp b/src/guiscalingfilter.cpp
index 92dadeaec6c75351695b89df9dd7f700250cc245..872d222d85759a3f8872afa8942db2cbca5d461e 100644 (file)
--- a/src/guiscalingfilter.cpp
+++ b/src/guiscalingfilter.cpp
@@ -28,54 +28,58 @@ 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 (!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,9 @@ 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)
+{
        return guiScalingResizeCached(driver, src,
                core::rect<s32>(0, 0, src->getSize().Width, src->getSize().Height),
                core::rect<s32>(0, 0, width, height));
@@ -146,8 +151,8 @@ 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);
 

diff --git a/src/imagefilters.cpp b/src/imagefilters.cpp
index a995e98d6267d1f13f5bd1f424b3e6614dff6754..b34027725a93728d6c54c6313efb357904811b97 100644 (file)
--- a/src/imagefilters.cpp
+++ b/src/imagefilters.cpp
@@ -31,8 +31,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
  * transparent.  Should be 127 for 3d where alpha is threshold, but 0 for
  * 2d where alpha is blended.
  */
-void imageCleanTransparent(video::IImage *src, u32 threshold) {
-
+void imageCleanTransparent(video::IImage *src, u32 threshold)
+{
        core::dimension2d<u32> dim = src->getDimension();
 
        // Walk each pixel looking for fully transparent ones.
@@ -85,8 +85,8 @@ void imageCleanTransparent(video::IImage *src, u32 threshold) {
  * filter is designed to produce the most accurate results for both upscaling
  * and downscaling.
  */
-void imageScaleNNAA(video::IImage *src, const core::rect<s32> &srcrect, video::IImage *dest) {
-
+void imageScaleNNAA(video::IImage *src, const core::rect<s32> &srcrect, video::IImage *dest)
+{
        double sx, sy, minsx, maxsx, minsy, maxsy, area, ra, ga, ba, aa, pw, ph, pa;
        u32 dy, dx;
        video::SColor pxl;