Fixed OpenGLGraphics::drawRescaledImagePattern

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

1 files changed, 45 insertions, 32 deletions

diff --git a/src/openglgraphics.cpp b/src/openglgraphics.cpp
index c24b7d64..84f499a4 100644
--- a/src/openglgraphics.cpp
+++ b/src/openglgraphics.cpp
@@ -478,24 +478,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);
@@ -505,23 +507,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;
@@ -538,14 +548,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)
@@ -560,38 +570,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)