Fixed OpenGLGraphics::drawRescaledImagePatternv0.5.3

This fixes overlay effects that are meant to scale with screen
resolution.

The problem was that the texture coordinates were not calculated
correctly. They were adjusted to the scaled size of the image, and when
scaling both the vertex and the texture coordinates, the image will
simply not appear scaled at all. Now the texture coordinates are
calculated based on the visible part of the original texture.

There was also a problem with the vertex coordinates, which were not
taking into account the visible part of the image.

TMW-Mantis-issue: 1047
Reviewed-by: Andrei Karas <akaras@inbox.ru>

2 files changed, 46 insertions, 32 deletions

diff --git a/NEWS b/NEWS
index 97478837..a6ebfce8 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,7 @@
 - Fixed endless loop when a sprite definition promises too many images
 - Fixed crash when selecting a character that has a Dark Talisman equipped
 - Fixed drawing glitch with overwide tiles
+- Fixed scaling of overlays in OpenGL mode
 - Fixed building without OpenGL
 
 0.5.2 (17 April 2011)
diff --git a/src/openglgraphics.cpp b/src/openglgraphics.cpp
index 7818e9d2..33346b47 100644
--- a/src/openglgraphics.cpp
+++ b/src/openglgraphics.cpp
@@ -480,24 +480,26 @@ void OpenGLGraphics::drawImagePattern(Image *image, int x, int y, int w, int h)
                static_cast<GLubyte>(mColor.a));
 }
 
-void OpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y,
-                                              int w, int h, int scaledWidth,
+void OpenGLGraphics::drawRescaledImagePattern(Image *image,
+                                              int x, int y,
+                                              int w, int h,
+                                              int scaledWidth,
                                               int scaledHeight)
 {
     if (!image)
         return;
 
+    if (scaledWidth == 0 || scaledHeight == 0)
+        return;
+
     const int srcX = image->mBounds.x;
     const int srcY = image->mBounds.y;
 
-    const int iw = scaledWidth;
-    const int ih = scaledHeight;
+    const int iw = image->getWidth();
+    const int ih = image->getHeight();
     if (iw == 0 || ih == 0)
         return;
 
-    const float tw = static_cast<float>(image->getTextureWidth());
-    const float th = static_cast<float>(image->getTextureHeight());
-
     glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
 
     bindTexture(Image::mTextureType, image->mGLImage);
@@ -507,23 +509,31 @@ void OpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y,
     unsigned int vp = 0;
     const unsigned int vLimit = vertexBufSize * 4;
 
-    float texX1 = static_cast<float>(srcX) / tw;
-    float texY1 = static_cast<float>(srcY) / th;
-
     // Draw a set of textured rectangles
     if (image->getTextureType() == GL_TEXTURE_2D)
     {
-        for (int py = 0; py < h; py += ih)
+        const float tw = static_cast<float>(image->getTextureWidth());
+        const float th = static_cast<float>(image->getTextureHeight());
+
+        const float texX1 = static_cast<float>(srcX) / tw;
+        const float texY1 = static_cast<float>(srcY) / th;
+
+        const float tFractionW = iw / tw;
+        const float tFractionH = ih / th;
+
+        for (int py = 0; py < h; py += scaledHeight)
         {
-            const int height = (py + ih >= h) ? h - py : ih;
+            const int height = (py + scaledHeight >= h) ? h - py : scaledHeight;
             const int dstY = y + py;
-            for (int px = 0; px < w; px += iw)
+            for (int px = 0; px < w; px += scaledWidth)
             {
-                int width = (px + iw >= w) ? w - px : iw;
+                int width = (px + scaledWidth >= w) ? w - px : scaledWidth;
                 int dstX = x + px;
+                const float visibleFractionW = (float) width / scaledWidth;
+                const float visibleFractionH = (float) height / scaledHeight;
 
-                float texX2 = static_cast<float>(srcX + width) / tw;
-                float texY2 = static_cast<float>(srcY + height) / th;
+                const float texX2 = texX1 + tFractionW * visibleFractionW;
+                const float texY2 = texY1 + tFractionH * visibleFractionH;
 
                 mFloatTexArray[vp + 0] = texX1;
                 mFloatTexArray[vp + 1] = texY1;
@@ -540,14 +550,14 @@ void OpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y,
                 mIntVertArray[vp + 0] = dstX;
                 mIntVertArray[vp + 1] = dstY;
 
-                mIntVertArray[vp + 2] = dstX + scaledWidth;
+                mIntVertArray[vp + 2] = dstX + width;
                 mIntVertArray[vp + 3] = dstY;
 
-                mIntVertArray[vp + 4] = dstX + scaledWidth;
-                mIntVertArray[vp + 5] = dstY + scaledHeight;
+                mIntVertArray[vp + 4] = dstX + width;
+                mIntVertArray[vp + 5] = dstY + height;
 
                 mIntVertArray[vp + 6] = dstX;
-                mIntVertArray[vp + 7] = dstY + scaledHeight;
+                mIntVertArray[vp + 7] = dstY + height;
 
                 vp += 8;
                 if (vp >= vLimit)
@@ -562,38 +572,41 @@ void OpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y,
     }
     else
     {
-        for (int py = 0; py < h; py += ih)
+        const float scaleFactorW = (float) scaledWidth / iw;
+        const float scaleFactorH = (float) scaledHeight / ih;
+
+        for (int py = 0; py < h; py += scaledHeight)
         {
-            const int height = (py + ih >= h) ? h - py : ih;
+            const int height = (py + scaledHeight >= h) ? h - py : scaledHeight;
             const int dstY = y + py;
-            for (int px = 0; px < w; px += iw)
+            for (int px = 0; px < w; px += scaledWidth)
             {
-                int width = (px + iw >= w) ? w - px : iw;
+                int width = (px + scaledWidth >= w) ? w - px : scaledWidth;
                 int dstX = x + px;
 
                 mIntTexArray[vp + 0] = srcX;
                 mIntTexArray[vp + 1] = srcY;
 
-                mIntTexArray[vp + 2] = srcX + width;
+                mIntTexArray[vp + 2] = srcX + width / scaleFactorW;
                 mIntTexArray[vp + 3] = srcY;
 
-                mIntTexArray[vp + 4] = srcX + width;
-                mIntTexArray[vp + 5] = srcY + height;
+                mIntTexArray[vp + 4] = srcX + width / scaleFactorW;
+                mIntTexArray[vp + 5] = srcY + height / scaleFactorH;
 
                 mIntTexArray[vp + 6] = srcX;
-                mIntTexArray[vp + 7] = srcY + height;
+                mIntTexArray[vp + 7] = srcY + height / scaleFactorH;
 
                 mIntVertArray[vp + 0] = dstX;
                 mIntVertArray[vp + 1] = dstY;
 
-                mIntVertArray[vp + 2] = dstX + scaledWidth;
+                mIntVertArray[vp + 2] = dstX + width;
                 mIntVertArray[vp + 3] = dstY;
 
-                mIntVertArray[vp + 4] = dstX + scaledWidth;
-                mIntVertArray[vp + 5] = dstY + scaledHeight;
+                mIntVertArray[vp + 4] = dstX + width;
+                mIntVertArray[vp + 5] = dstY + height;
 
                 mIntVertArray[vp + 6] = dstX;
-                mIntVertArray[vp + 7] = dstY + scaledHeight;
+                mIntVertArray[vp + 7] = dstY + height;
 
                 vp += 8;
                 if (vp >= vLimit)