1 files changed, 68 insertions, 12 deletions

diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 3ddc15a..668a3f0 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -163,6 +163,8 @@ void QGL2PaintEngineExPrivate::setBrush(const QBrush& brush)
     Q_ASSERT(newStyle != Qt::NoBrush);
 
     currentBrush = brush;
+    if (!currentBrushPixmap.isNull())
+        currentBrushPixmap = QPixmap();
     brushUniformsDirty = true; // All brushes have at least one uniform
 
     if (newStyle > Qt::SolidPattern)
@@ -221,10 +223,14 @@ void QGL2PaintEngineExPrivate::updateBrushTexture()
             updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE, q->state()->renderHints & QPainter::SmoothPixmapTransform);
     }
     else if (style == Qt::TexturePattern) {
-        const QPixmap& texPixmap = currentBrush.texture();
+        currentBrushPixmap = currentBrush.texture();
+
+        int max_texture_size = ctx->d_func()->maxTextureSize();
+        if (currentBrushPixmap.width() > max_texture_size || currentBrushPixmap.height() > max_texture_size)
+            currentBrushPixmap = currentBrushPixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
 
         glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
-        QGLTexture *tex = ctx->d_func()->bindTexture(texPixmap, GL_TEXTURE_2D, GL_RGBA,
+        QGLTexture *tex = ctx->d_func()->bindTexture(currentBrushPixmap, GL_TEXTURE_2D, GL_RGBA,
                                                      QGLContext::InternalBindOption |
                                                      QGLContext::CanFlipNativePixmapBindOption);
         updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
@@ -1305,13 +1311,30 @@ void QGL2PaintEngineEx::transformChanged()
 }
 
 
+static const QRectF scaleRect(const QRectF &r, qreal sx, qreal sy)
+{
+    return QRectF(r.x() * sx, r.y() * sy, r.width() * sx, r.height() * sy);
+}
+
 void QGL2PaintEngineEx::drawPixmap(const QRectF& dest, const QPixmap & pixmap, const QRectF & src)
 {
     Q_D(QGL2PaintEngineEx);
+    QGLContext *ctx = d->ctx;
+
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+
+        const qreal sx = scaled.width() / qreal(pixmap.width());
+        const qreal sy = scaled.height() / qreal(pixmap.height());
+
+        drawPixmap(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
+
     ensureActive();
     d->transferMode(ImageDrawingMode);
 
-    QGLContext *ctx = d->ctx;
     glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
     QGLTexture *texture =
         ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA,
@@ -1334,11 +1357,24 @@ void QGL2PaintEngineEx::drawImage(const QRectF& dest, const QImage& image, const
                         Qt::ImageConversionFlags)
 {
     Q_D(QGL2PaintEngineEx);
+    QGLContext *ctx = d->ctx;
+
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (image.width() > max_texture_size || image.height() > max_texture_size) {
+        QImage scaled = image.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+
+        const qreal sx = scaled.width() / qreal(image.width());
+        const qreal sy = scaled.height() / qreal(image.height());
+
+        drawImage(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
+
     ensureActive();
     d->transferMode(ImageDrawingMode);
 
-    QGLContext *ctx = d->ctx;
     glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
+
     QGLTexture *texture = ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
     GLuint id = texture->id;
 
@@ -1464,6 +1500,7 @@ namespace {
         QSize cacheSize;
         QGL2PEXVertexArray vertexCoordinateArray;
         QGL2PEXVertexArray textureCoordinateArray;
+        QFontEngineGlyphCache::Type glyphType;
     };
 
 }
@@ -1477,22 +1514,29 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
 
     QOpenGL2PaintEngineState *s = q->state();
 
+    bool recreateVertexArrays = false;
+
     QGLTextureGlyphCache *cache =
         (QGLTextureGlyphCache *) staticTextItem->fontEngine()->glyphCache(ctx, glyphType, QTransform());
     if (!cache || cache->cacheType() != glyphType) {
         cache = new QGLTextureGlyphCache(ctx, glyphType, QTransform());
         staticTextItem->fontEngine()->setGlyphCache(ctx, cache);
+        recreateVertexArrays = true;
     } else if (cache->context() == 0) { // Old context has been destroyed, new context has same ptr value
         cache->setContext(ctx);
     }
 
-    bool recreateVertexArrays = false;
-    if (staticTextItem->userDataNeedsUpdate)
+    if (staticTextItem->userDataNeedsUpdate) {
         recreateVertexArrays = true;
-    else if (staticTextItem->userData() == 0)
+    } else if (staticTextItem->userData() == 0) {
         recreateVertexArrays = true;
-    else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData)
+    } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
         recreateVertexArrays = true;
+    } else {
+        QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
+        if (userData->glyphType != glyphType)
+            recreateVertexArrays = true;
+    }
 
     // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
     // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
@@ -1504,8 +1548,8 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
 	    // No space in cache. We need to clear the cache and try again
             cache->clear();
             cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
-			    staticTextItem->glyphs, staticTextItem->glyphPositions);
-	}
+                            staticTextItem->glyphs, staticTextItem->glyphPositions);
+        }
     }
 
     if (cache->width() == 0 || cache->height() == 0)
@@ -1535,6 +1579,8 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
             userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
         }
 
+        userData->glyphType = glyphType;
+
         // Use cache if backend optimizations is turned on
         vertexCoordinates = &userData->vertexCoordinateArray;
         textureCoordinates = &userData->textureCoordinateArray;
@@ -1727,7 +1773,13 @@ void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *frag
     }
 
     ensureActive();
-    d->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    int max_texture_size = d->ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+        d->drawPixmapFragments(fragments, fragmentCount, scaled, hints);
+    } else {
+        d->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    }
 }
 
 
@@ -2139,7 +2191,11 @@ void QGL2PaintEngineEx::clip(const QVectorPath &path, Qt::ClipOperation op)
         const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
         QRectF rect(points[0], points[2]);
 
-        if (state()->matrix.type() <= QTransform::TxScale) {
+        if (state()->matrix.type() <= QTransform::TxScale
+            || (state()->matrix.type() == QTransform::TxRotate
+                && qFuzzyIsNull(state()->matrix.m11())
+                && qFuzzyIsNull(state()->matrix.m22())))
+        {
             state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
             d->updateClipScissorTest();
             return;