--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/opengl/qpaintengine_opengl.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,5626 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qdebug.h>
+#include <private/qfontengine_p.h>
+#include <qmath.h>
+#include <private/qmath_p.h>
+#include <private/qdrawhelper_p.h>
+#include <private/qpaintengine_p.h>
+#include "qapplication.h"
+#include "qbrush.h"
+#include "qgl.h"
+#include <private/qgl_p.h>
+#include <private/qglpaintdevice_p.h>
+#include <private/qpainter_p.h>
+#include "qmap.h"
+#include <private/qpaintengine_opengl_p.h>
+#include <private/qdatabuffer_p.h>
+#include "qpen.h"
+#include "qvarlengtharray.h"
+#include <private/qpainter_p.h>
+#include <private/qglpixelbuffer_p.h>
+#include <private/qbezier_p.h>
+#include <qglframebufferobject.h>
+
+#include "private/qtessellator_p.h"
+
+#include "util/fragmentprograms_p.h"
+
+#ifdef Q_WS_QWS
+#include "private/qglwindowsurface_qws_p.h"
+#include "qwsmanager_qws.h"
+#include "private/qwsmanager_p.h"
+#endif
+
+#ifdef QT_OPENGL_ES_1_CL
+#include "qgl_cl_p.h"
+#endif
+
+#define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context());
+
+#include <stdlib.h>
+#include "qpaintengine_opengl_p.h"
+
+QT_BEGIN_NAMESPACE
+
+extern QImage qt_imageForBrush(int brushStyle, bool invert); //in qbrush.cpp
+#ifdef QT_MAC_USE_COCOA
+extern void *qt_current_nsopengl_context(); // qgl_mac.mm
+#endif
+
+#define QREAL_MAX 9e100
+#define QREAL_MIN -9e100
+
+extern int qt_next_power_of_two(int v);
+
+#define DISABLE_DEBUG_ONCE
+
+//#define DEBUG_DISPLAY_MASK_TEXTURE
+
+#ifdef DISABLE_DEBUG_ONCE
+#define DEBUG_OVERRIDE(state) ;
+#define DEBUG_ONCE_STR(str) ;
+#define DEBUG_ONCE if (0)
+#else
+static int DEBUG_OVERRIDE_FLAG = 0;
+static bool DEBUG_TEMP_FLAG;
+#define DEBUG_OVERRIDE(state) { state ? ++DEBUG_OVERRIDE_FLAG : --DEBUG_OVERRIDE_FLAG; }
+#define DEBUG_ONCE if ((DEBUG_TEMP_FLAG = DEBUG_OVERRIDE_FLAG) && 0) ; else for (static int DEBUG_ONCE_FLAG = false; !DEBUG_ONCE_FLAG || DEBUG_TEMP_FLAG; DEBUG_ONCE_FLAG = true, DEBUG_TEMP_FLAG = false)
+#define DEBUG_ONCE_STR(str) DEBUG_ONCE qDebug() << (str);
+#endif
+
+static inline void qt_glColor4ubv(unsigned char *col)
+{
+#ifdef QT_OPENGL_ES
+ glColor4f(col[0]/255.0, col[1]/255.0, col[2]/255.0, col[3]/255.0);
+#else
+ glColor4ubv(col);
+#endif
+}
+
+struct QT_PointF {
+ qreal x;
+ qreal y;
+};
+
+struct QGLTrapezoid
+{
+ QGLTrapezoid()
+ {}
+
+ QGLTrapezoid(qreal top_, qreal bottom_, qreal topLeftX_, qreal topRightX_, qreal bottomLeftX_, qreal bottomRightX_)
+ : top(top_),
+ bottom(bottom_),
+ topLeftX(topLeftX_),
+ topRightX(topRightX_),
+ bottomLeftX(bottomLeftX_),
+ bottomRightX(bottomRightX_)
+ {}
+
+ const QGLTrapezoid translated(const QPointF &delta) const;
+
+ qreal top;
+ qreal bottom;
+ qreal topLeftX;
+ qreal topRightX;
+ qreal bottomLeftX;
+ qreal bottomRightX;
+};
+
+const QGLTrapezoid QGLTrapezoid::translated(const QPointF &delta) const
+{
+ QGLTrapezoid trap(*this);
+ trap.top += delta.y();
+ trap.bottom += delta.y();
+ trap.topLeftX += delta.x();
+ trap.topRightX += delta.x();
+ trap.bottomLeftX += delta.x();
+ trap.bottomRightX += delta.x();
+ return trap;
+}
+
+
+class QOpenGLImmediateModeTessellator;
+class QGLMaskGenerator;
+class QGLOffscreen;
+
+class QGLMaskTextureCache
+{
+public:
+ void setOffscreenSize(const QSize &offscreenSize);
+ void setDrawableSize(const QSize &drawableSize);
+
+ struct CacheLocation {
+ QRect rect;
+ int channel;
+
+ QRect screen_rect;
+ };
+
+ struct CacheInfo {
+ inline CacheInfo(const QPainterPath &p, const QTransform &m, qreal w = -1) :
+ path(p), matrix(m), stroke_width(w), age(0) {}
+
+ QPainterPath path;
+ QTransform matrix;
+ qreal stroke_width;
+
+ CacheLocation loc;
+
+ int age;
+ };
+
+ struct QuadTreeNode {
+ quint64 key;
+
+ int largest_available_block;
+ int largest_used_block;
+ };
+
+ CacheLocation getMask(QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *engine);
+
+ typedef QMultiHash<quint64, CacheInfo> QGLTextureCacheHash;
+
+ enum {block_size = 64};
+
+ // throw out keys that are too old
+ void maintainCache();
+ void clearCache();
+
+private:
+ quint64 hash(const QPainterPath &p, const QTransform &m, qreal w);
+
+ void createMask(quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator);
+
+ QSize offscreenSize;
+ QSize drawableSize;
+
+ QGLTextureCacheHash cache;
+
+ QVector<QuadTreeNode> occupied_quadtree[4];
+
+ void quadtreeUpdate(int channel, int node, int current_block_size);
+ void quadtreeAllocate(quint64 key, const QSize &size, QRect *rect, int *channel);
+
+ bool quadtreeFindAvailableLocation(const QSize &size, QRect *rect, int *channel);
+ void quadtreeFindExistingLocation(const QSize &size, QRect *rect, int *channel);
+
+ void quadtreeInsert(int channel, quint64 key, const QRect &rect, int node = 0);
+ void quadtreeClear(int channel, const QRect &rect, int node = 0);
+
+ int quadtreeBlocksize(int node);
+ QPoint quadtreeLocation(int node);
+
+ QOpenGLPaintEnginePrivate *engine;
+};
+
+Q_GLOBAL_STATIC(QGLMaskTextureCache, qt_mask_texture_cache)
+
+class QGLOffscreen : public QObject
+{
+ Q_OBJECT
+public:
+ QGLOffscreen()
+ : QObject(),
+ offscreen(0),
+ ctx(0),
+ mask_dim(0),
+ activated(false),
+ bound(false)
+ {
+ connect(QGLSignalProxy::instance(),
+ SIGNAL(aboutToDestroyContext(const QGLContext *)),
+ SLOT(cleanupGLContextRefs(const QGLContext *)));
+ }
+
+ inline void setDevice(QPaintDevice *pdev);
+
+ void begin();
+ void end();
+
+ inline void bind();
+ inline void release();
+
+ inline bool isBound() const;
+
+ inline QSize drawableSize() const;
+ inline QSize offscreenSize() const;
+
+ inline GLuint offscreenTexture() const;
+
+ QGLContext *context() const;
+
+ static bool isSupported();
+
+ inline void initialize();
+
+ inline bool isValid() const;
+
+public Q_SLOTS:
+ void cleanupGLContextRefs(const QGLContext *context) {
+ if (context == ctx) {
+ delete offscreen;
+ ctx = 0;
+ offscreen = 0;
+ mask_dim = 0;
+ }
+ }
+
+private:
+ QGLPaintDevice* device;
+
+ QGLFramebufferObject *offscreen;
+ QGLContext *ctx;
+
+ // dimensions of mask texture (square)
+ int mask_dim;
+ QSize last_failed_size;
+
+ bool drawable_fbo;
+
+ bool activated;
+ bool initialized;
+
+ bool bound;
+};
+
+inline void QGLOffscreen::setDevice(QPaintDevice *pdev)
+{
+ if (pdev->devType() == QInternal::OpenGL)
+ device = static_cast<QGLPaintDevice*>(pdev);
+ else
+ device = QGLPaintDevice::getDevice(pdev);
+
+ if (!device)
+ return;
+
+ drawable_fbo = (pdev->devType() == QInternal::FramebufferObject);
+}
+
+void QGLOffscreen::begin()
+{
+#ifndef QT_OPENGL_ES
+ initialized = false;
+
+ if (activated)
+ initialize();
+#endif
+}
+
+void QGLOffscreen::initialize()
+{
+#ifndef QT_OPENGL_ES
+ if (initialized)
+ return;
+
+ activated = true;
+ initialized = true;
+
+ int dim = qMax(2048, static_cast<int>(qt_next_power_of_two(qMax(device->size().width(), device->size().height()))));
+
+ bool shared_context = QGLContext::areSharing(device->context(), ctx);
+ bool would_fail = last_failed_size.isValid() &&
+ (device->size().width() >= last_failed_size.width() ||
+ device->size().height() >= last_failed_size.height());
+ bool needs_refresh = dim > mask_dim || !shared_context;
+
+ if (needs_refresh && !would_fail) {
+ DEBUG_ONCE qDebug() << "QGLOffscreen::initialize(): creating offscreen of size" << dim;
+ delete offscreen;
+ offscreen = new QGLFramebufferObject(dim, dim, GLenum(GL_TEXTURE_2D));
+ mask_dim = dim;
+
+ if (!offscreen->isValid()) {
+ qWarning("QGLOffscreen: Invalid offscreen fbo (size %dx%d)", mask_dim, mask_dim);
+ delete offscreen;
+ offscreen = 0;
+ mask_dim = 0;
+ last_failed_size = device->size();
+ }
+ }
+
+ qt_mask_texture_cache()->setOffscreenSize(offscreenSize());
+ qt_mask_texture_cache()->setDrawableSize(device->size());
+ ctx = device->context();
+#endif
+}
+
+inline bool QGLOffscreen::isValid() const
+{
+ return offscreen;
+}
+
+void QGLOffscreen::end()
+{
+ if (bound)
+ release();
+#ifdef DEBUG_DISPLAY_MASK_TEXTURE
+ glReadBuffer(GL_BACK);
+ glDrawBuffer(GL_BACK);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glColor4f(1, 1, 1, 1);
+ glDisable(GL_DEPTH_TEST);
+ glBlendFunc(GL_ONE, GL_ZERO);
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, offscreen->texture());
+
+ glBegin(GL_QUADS);
+ glTexCoord2f(0.0, 1.0); glVertex2f(0.0, 0.0);
+ glTexCoord2f(1.0, 1.0); glVertex2f(drawable.size().width(), 0.0);
+ glTexCoord2f(1.0, 0.0); glVertex2f(drawable.size().width(), drawable.size().height());
+ glTexCoord2f(0.0, 0.0); glVertex2f(0.0, drawable.size().height());
+ glEnd();
+
+ glBindTexture(GL_TEXTURE_2D, 0);
+ glDisable(GL_TEXTURE_2D);
+#endif
+}
+
+inline void QGLOffscreen::bind()
+{
+#ifndef QT_OPENGL_ES
+ Q_ASSERT(initialized);
+
+ if (!offscreen || bound)
+ return;
+
+ DEBUG_ONCE qDebug() << "QGLOffscreen: binding offscreen";
+ offscreen->bind();
+
+ bound = true;
+
+ glViewport(0, 0, offscreenSize().width(), offscreenSize().height());
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(0, offscreenSize().width(), offscreenSize().height(), 0, -999999, 999999);
+ glMatrixMode(GL_MODELVIEW);
+#endif
+}
+
+inline void QGLOffscreen::release()
+{
+#ifndef QT_OPENGL_ES
+ if (!offscreen || !bound)
+ return;
+
+#ifdef Q_WS_X11
+ // workaround for bug in nvidia driver versions 9x.xx
+ if (QGLExtensions::nvidiaFboNeedsFinish)
+ glFinish();
+#endif
+
+ DEBUG_ONCE_STR("QGLOffscreen: releasing offscreen");
+
+ if (drawable_fbo)
+ device->ensureActiveTarget(); //###
+ else
+ offscreen->release();
+
+ QSize sz(device->size());
+ glViewport(0, 0, sz.width(), sz.height());
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+#ifndef QT_OPENGL_ES
+ glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
+#else
+ glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);
+#endif
+ glMatrixMode(GL_MODELVIEW);
+
+ bound = false;
+#endif
+}
+
+inline bool QGLOffscreen::isBound() const
+{
+ return bound;
+}
+
+inline QSize QGLOffscreen::drawableSize() const
+{
+ return device->size();
+}
+
+inline QSize QGLOffscreen::offscreenSize() const
+{
+ return QSize(mask_dim, mask_dim);
+}
+
+inline GLuint QGLOffscreen::offscreenTexture() const
+{
+ return offscreen ? offscreen->texture() : 0;
+}
+
+inline QGLContext *QGLOffscreen::context() const
+{
+ return ctx;
+}
+
+bool QGLOffscreen::isSupported()
+{
+ return (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject); // for fbo
+}
+
+struct QDrawQueueItem
+{
+ QDrawQueueItem(qreal _opacity,
+ QBrush _brush,
+ const QPointF &_brush_origion,
+ QPainter::CompositionMode _composition_mode,
+ const QTransform &_matrix,
+ QGLMaskTextureCache::CacheLocation _location)
+ : opacity(_opacity),
+ brush(_brush),
+ brush_origin(_brush_origion),
+ composition_mode(_composition_mode),
+ matrix(_matrix),
+ location(_location) {}
+ qreal opacity;
+ QBrush brush;
+ QPointF brush_origin;
+ QPainter::CompositionMode composition_mode;
+
+ QTransform matrix;
+ QGLMaskTextureCache::CacheLocation location;
+};
+
+////////// GL program cache: start
+
+typedef struct {
+ int brush; // brush index or mask index
+ int mode; // composition mode index
+ bool mask;
+ GLuint program;
+} GLProgram;
+
+typedef QMultiHash<const QGLContext *, GLProgram> QGLProgramHash;
+
+class QGLProgramCache : public QObject
+{
+ Q_OBJECT
+public:
+ QGLProgramCache() {
+ // we have to know when a context is deleted so we can free
+ // any program handles it holds
+ connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext *)),
+ SLOT(cleanupPrograms(const QGLContext *)));
+
+ }
+ ~QGLProgramCache() {
+ // at this point the cache should contain 0 elements
+ // Q_ASSERT(program.size() == 0);
+ }
+
+ GLuint getProgram(const QGLContext *ctx, int brush, int mode, bool mask_mode)
+ {
+ // 1. see if we have an entry for the ctx context
+ QList<GLProgram> progs = programs.values(ctx);
+ for (int i=0; i<progs.size(); ++i) {
+ const GLProgram &prg = progs.at(i);
+ if (mask_mode) {
+ if (prg.mask && prg.brush == brush)
+ return prg.program;
+ } else {
+ if (!prg.mask && prg.brush == brush && prg.mode == mode)
+ return prg.program;
+ }
+ }
+
+ // 2. try to find a match in a shared context, and update the
+ // hash with the entry found
+ QList<const QGLContext *> contexts = programs.uniqueKeys();
+ for (int i=0; i<contexts.size(); ++i) {
+ const QGLContext *cx = contexts.at(i);
+ if (cx != ctx && QGLContext::areSharing(cx, ctx)) {
+ QList<GLProgram> progs = programs.values(cx);
+ for (int k=0; k<progs.size(); ++k) {
+ const GLProgram &prg = progs.at(k);
+ if (mask_mode) {
+ if (prg.mask && prg.brush == brush) {
+ programs.insert(ctx, prg);
+ return prg.program;
+ }
+ } else {
+ if (!prg.mask && prg.brush == brush && prg.mode == mode) {
+ programs.insert(ctx, prg);
+ return prg.program;
+ }
+ }
+ }
+ }
+ }
+
+ // 3. compile a new program and place it into the cache
+ // NB! assumes ctx is the current GL context
+ GLProgram prg;
+ prg.brush = brush;
+ prg.mode = mode;
+ prg.mask = mask_mode;
+ glGenProgramsARB(1, &prg.program);
+ glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prg.program);
+ const char *src = mask_mode
+ ? mask_fragment_program_sources[brush]
+ : painter_fragment_program_sources[brush][mode];
+ // necessary for .NET 2002, apparently
+ const GLbyte *gl_src = reinterpret_cast<const GLbyte *>(src);
+
+ while (glGetError() != GL_NO_ERROR) {} // reset error state
+ glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
+ int(strlen(src)), gl_src);
+ if (glGetError() != GL_NO_ERROR) {
+// qDebug() << "QGLProgramCache: Unable to compile fragment program.";
+ glDeleteProgramsARB(1, &prg.program);
+ return 0;
+ }
+
+// qDebug() << "QGLProgramCache: Creating GL program:" << prg.program << hex << ctx;
+ programs.insert(ctx, prg);
+ return prg.program;
+ }
+
+public Q_SLOTS:
+ void cleanupPrograms(const QGLContext *context)
+ {
+ QGLProgramHash::iterator it = programs.begin();
+ while (it != programs.end()) {
+ if (it.key() == context) {
+ if (!context->isSharing()) {
+ // the ctx variable below is needed for the glDeleteProgramARB call
+ // since it is resolved from our extension system
+ // NB! assumes context is the current GL context
+ const QGLContext *ctx = context;
+ // qDebug() << "QGLProgramHash: Deleting GL program:" << it.value().program << hex << it.key();
+ glDeleteProgramsARB(1, &it.value().program);
+ }
+ it = programs.erase(it);
+ } else {
+ ++it;
+ }
+ }
+ }
+
+private:
+ QGLProgramHash programs;
+};
+
+Q_GLOBAL_STATIC(QGLProgramCache, qt_gl_program_cache)
+
+////////// GL program cache: end
+
+class QOpenGLPaintEnginePrivate;
+class QGLPrivateCleanup : public QObject
+{
+ Q_OBJECT
+public:
+ QGLPrivateCleanup(QOpenGLPaintEnginePrivate *priv)
+ : p(priv)
+ {
+ connect(QGLSignalProxy::instance(),
+ SIGNAL(aboutToDestroyContext(const QGLContext *)),
+ SLOT(cleanupGLContextRefs(const QGLContext *)));
+ }
+
+public Q_SLOTS:
+ void cleanupGLContextRefs(const QGLContext *context);
+
+private:
+ QOpenGLPaintEnginePrivate *p;
+};
+
+class QOpenGLPaintEnginePrivate : public QPaintEngineExPrivate
+{
+ Q_DECLARE_PUBLIC(QOpenGLPaintEngine)
+public:
+ QOpenGLPaintEnginePrivate()
+ : opacity(1)
+ , composition_mode(QPainter::CompositionMode_SourceOver)
+ , has_fast_pen(false)
+ , use_stencil_method(false)
+ , dirty_drawable_texture(false)
+ , has_stencil_face_ext(false)
+ , use_fragment_programs(false)
+ , high_quality_antialiasing(false)
+ , use_smooth_pixmap_transform(false)
+ , use_emulation(false)
+ , txop(QTransform::TxNone)
+ , inverseScale(1)
+ , moveToCount(0)
+ , last_created_state(0)
+ , shader_ctx(0)
+ , grad_palette(0)
+ , drawable_texture(0)
+ , ref_cleaner(this)
+ {}
+
+ inline void setGLPen(const QColor &c) {
+ uint alpha = qRound(c.alpha() * opacity);
+ pen_color[0] = qt_div_255(c.red() * alpha);
+ pen_color[1] = qt_div_255(c.green() * alpha);
+ pen_color[2] = qt_div_255(c.blue() * alpha);
+ pen_color[3] = alpha;
+ }
+
+ inline void setGLBrush(const QColor &c) {
+ uint alpha = qRound(c.alpha() * opacity);
+ brush_color[0] = qt_div_255(c.red() * alpha);
+ brush_color[1] = qt_div_255(c.green() * alpha);
+ brush_color[2] = qt_div_255(c.blue() * alpha);
+ brush_color[3] = alpha;
+ }
+
+ inline void setGradientOps(const QBrush &brush, const QRectF &bounds);
+ void createGradientPaletteTexture(const QGradient& g);
+
+ void updateGradient(const QBrush &brush, const QRectF &bounds);
+
+ inline void lineToStencil(qreal x, qreal y);
+ inline void curveToStencil(const QPointF &cp1, const QPointF &cp2, const QPointF &ep);
+ void pathToVertexArrays(const QPainterPath &path);
+ void fillVertexArray(Qt::FillRule fillRule);
+ void drawVertexArrays();
+ void fillPath(const QPainterPath &path);
+ void fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
+ Qt::FillRule fill);
+
+ void drawFastRect(const QRectF &rect);
+ void strokePath(const QPainterPath &path, bool use_cache);
+ void strokePathFastPen(const QPainterPath &path, bool needsResolving);
+ void strokeLines(const QPainterPath &path);
+
+ void updateDepthClip();
+ void systemStateChanged();
+
+ void cleanupGLContextRefs(const QGLContext *context) {
+ if (context == shader_ctx)
+ shader_ctx = 0;
+ }
+
+ inline void updateFastPen() {
+ qreal pen_width = cpen.widthF();
+ has_fast_pen =
+ ((pen_width == 0 || (pen_width <= 1 && matrix.type() <= QTransform::TxTranslate))
+ || cpen.isCosmetic())
+ && cpen.style() == Qt::SolidLine
+ && cpen.isSolid();
+
+ }
+
+ void disableClipping();
+ void enableClipping();
+ void ensureDrawableTexture();
+
+ QPen cpen;
+ QBrush cbrush;
+ Qt::BrushStyle brush_style;
+ QPointF brush_origin;
+ Qt::BrushStyle pen_brush_style;
+ qreal opacity;
+ QPainter::CompositionMode composition_mode;
+
+ Qt::BrushStyle current_style;
+
+ uint has_pen : 1;
+ uint has_brush : 1;
+ uint has_fast_pen : 1;
+ uint use_stencil_method : 1;
+ uint dirty_drawable_texture : 1;
+ uint has_stencil_face_ext : 1;
+ uint use_fragment_programs : 1;
+ uint high_quality_antialiasing : 1;
+ uint has_antialiasing : 1;
+ uint has_fast_composition_mode : 1;
+ uint use_smooth_pixmap_transform : 1;
+ uint use_system_clip : 1;
+ uint use_emulation : 1;
+
+ QRegion dirty_stencil;
+
+ void updateUseEmulation();
+
+ QTransform matrix;
+ GLubyte pen_color[4];
+ GLubyte brush_color[4];
+ QTransform::TransformationType txop;
+ QGLPaintDevice* device;
+ QGLOffscreen offscreen;
+
+ qreal inverseScale;
+
+ int moveToCount;
+ QPointF path_start;
+
+ bool isFastRect(const QRectF &r);
+
+ void drawImageAsPath(const QRectF &r, const QImage &img, const QRectF &sr);
+ void drawTiledImageAsPath(const QRectF &r, const QImage &img, qreal sx, qreal sy, const QPointF &offset);
+
+ void drawOffscreenPath(const QPainterPath &path);
+
+ void composite(const QRectF &rect, const QPoint &maskOffset = QPoint());
+ void composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
+
+ bool createFragmentPrograms();
+ void deleteFragmentPrograms();
+ void updateFragmentProgramData(int locations[]);
+
+ void cacheItemErased(int channel, const QRect &rect);
+
+ void addItem(const QGLMaskTextureCache::CacheLocation &location);
+ void drawItem(const QDrawQueueItem &item);
+ void flushDrawQueue();
+
+ void copyDrawable(const QRectF &rect);
+
+ void updateGLMatrix() const;
+
+ mutable QPainterState *last_created_state;
+
+ QGLContext *shader_ctx;
+ GLuint grad_palette;
+
+ GLuint painter_fragment_programs[num_fragment_brushes][num_fragment_composition_modes];
+ GLuint mask_fragment_programs[num_fragment_masks];
+
+ float inv_matrix_data[3][4];
+ float fmp_data[4];
+ float fmp2_m_radius2_data[4];
+ float angle_data[4];
+ float linear_data[4];
+
+ float porterduff_ab_data[4];
+ float porterduff_xyz_data[4];
+
+ float mask_offset_data[4];
+ float mask_channel_data[4];
+
+ FragmentBrushType fragment_brush;
+ FragmentCompositionModeType fragment_composition_mode;
+
+ void setPorterDuffData(float a, float b, float x, float y, float z);
+ void setInvMatrixData(const QTransform &inv_matrix);
+
+ qreal max_x;
+ qreal max_y;
+ qreal min_x;
+ qreal min_y;
+
+ QDataBuffer<QPointF> tess_points;
+ QVector<int> tess_points_stops;
+
+ GLdouble projection_matrix[4][4];
+
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
+ GLfloat mv_matrix[4][4];
+#else
+ GLdouble mv_matrix[4][4];
+#endif
+
+ QList<QDrawQueueItem> drawQueue;
+
+ GLuint drawable_texture;
+ QSize drawable_texture_size;
+
+ int max_texture_size;
+
+ QGLPrivateCleanup ref_cleaner;
+ friend class QGLMaskTextureCache;
+};
+
+class QOpenGLCoordinateOffset
+{
+public:
+ QOpenGLCoordinateOffset(QOpenGLPaintEnginePrivate *d);
+ ~QOpenGLCoordinateOffset();
+
+ static void enableOffset(QOpenGLPaintEnginePrivate *d);
+ static void disableOffset(QOpenGLPaintEnginePrivate *d);
+
+private:
+ QOpenGLPaintEnginePrivate *d;
+};
+
+QOpenGLCoordinateOffset::QOpenGLCoordinateOffset(QOpenGLPaintEnginePrivate *d_)
+ : d(d_)
+{
+ enableOffset(d);
+}
+
+void QOpenGLCoordinateOffset::enableOffset(QOpenGLPaintEnginePrivate *d)
+{
+ if (!d->has_antialiasing) {
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ d->mv_matrix[3][0] += 0.5;
+ d->mv_matrix[3][1] += 0.5;
+ d->updateGLMatrix();
+ }
+}
+
+QOpenGLCoordinateOffset::~QOpenGLCoordinateOffset()
+{
+ disableOffset(d);
+}
+
+void QOpenGLCoordinateOffset::disableOffset(QOpenGLPaintEnginePrivate *d)
+{
+ if (!d->has_antialiasing) {
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ d->mv_matrix[3][0] -= 0.5;
+ d->mv_matrix[3][1] -= 0.5;
+ }
+}
+
+void QGLPrivateCleanup::cleanupGLContextRefs(const QGLContext *context)
+{
+ p->cleanupGLContextRefs(context);
+}
+
+
+static inline void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform)
+{
+ if (smoothPixmapTransform) {
+ glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ } else {
+ glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ }
+ glTexParameterf(target, GL_TEXTURE_WRAP_S, wrapMode);
+ glTexParameterf(target, GL_TEXTURE_WRAP_T, wrapMode);
+}
+
+static inline QPainterPath strokeForPath(const QPainterPath &path, const QPen &cpen) {
+ QPainterPathStroker stroker;
+ if (cpen.style() == Qt::CustomDashLine)
+ stroker.setDashPattern(cpen.dashPattern());
+ else
+ stroker.setDashPattern(cpen.style());
+
+ stroker.setCapStyle(cpen.capStyle());
+ stroker.setJoinStyle(cpen.joinStyle());
+ stroker.setMiterLimit(cpen.miterLimit());
+
+ qreal width = cpen.widthF();
+ if (width == 0)
+ stroker.setWidth(1);
+ else
+ stroker.setWidth(width);
+
+ QPainterPath stroke = stroker.createStroke(path);
+ stroke.setFillRule(Qt::WindingFill);
+ return stroke;
+}
+
+class QGLStrokeCache
+{
+ struct CacheInfo
+ {
+ inline CacheInfo(QPainterPath p, QPainterPath sp, QPen stroke_pen) :
+ path(p), stroked_path(sp), pen(stroke_pen) {}
+ QPainterPath path;
+ QPainterPath stroked_path;
+ QPen pen;
+ };
+
+ typedef QMultiHash<quint64, CacheInfo> QGLStrokeTableHash;
+
+public:
+ inline QPainterPath getStrokedPath(const QPainterPath &path, const QPen &pen) {
+ quint64 hash_val = 0;
+
+ for (int i = 0; i < path.elementCount() && i <= 2; i++) {
+ hash_val += quint64(path.elementAt(i).x);
+ hash_val += quint64(path.elementAt(i).y);
+ }
+
+ QGLStrokeTableHash::const_iterator it = cache.constFind(hash_val);
+
+ if (it == cache.constEnd())
+ return addCacheElement(hash_val, path, pen);
+ else {
+ do {
+ const CacheInfo &cache_info = it.value();
+ if (cache_info.path == path && cache_info.pen == pen)
+ return cache_info.stroked_path;
+ ++it;
+ } while (it != cache.constEnd() && it.key() == hash_val);
+ // an exact match for this path was not found, create new cache element
+ return addCacheElement(hash_val, path, pen);
+ }
+ }
+
+protected:
+ inline int maxCacheSize() const { return 500; }
+ QPainterPath addCacheElement(quint64 hash_val, QPainterPath path, const QPen &pen) {
+ if (cache.size() == maxCacheSize()) {
+ int elem_to_remove = qrand() % maxCacheSize();
+ cache.remove(cache.keys()[elem_to_remove]); // may remove more than 1, but OK
+ }
+ QPainterPath stroke = strokeForPath(path, pen);
+ CacheInfo cache_entry(path, stroke, pen);
+ return cache.insert(hash_val, cache_entry).value().stroked_path;
+ }
+
+ QGLStrokeTableHash cache;
+};
+
+Q_GLOBAL_STATIC(QGLStrokeCache, qt_opengl_stroke_cache)
+
+class QGLGradientCache : public QObject
+{
+ Q_OBJECT
+ struct CacheInfo
+ {
+ inline CacheInfo(QGradientStops s, qreal op, QGradient::InterpolationMode mode) :
+ stops(s), opacity(op), interpolationMode(mode) {}
+
+ GLuint texId;
+ QGradientStops stops;
+ qreal opacity;
+ QGradient::InterpolationMode interpolationMode;
+ };
+
+ typedef QMultiHash<quint64, CacheInfo> QGLGradientColorTableHash;
+
+public:
+ QGLGradientCache() : QObject(), buffer_ctx(0)
+ {
+ connect(QGLSignalProxy::instance(),
+ SIGNAL(aboutToDestroyContext(const QGLContext *)),
+ SLOT(cleanupGLContextRefs(const QGLContext *)));
+ }
+
+ inline GLuint getBuffer(const QGradient &gradient, qreal opacity, QGLContext *ctx) {
+ if (buffer_ctx && !QGLContext::areSharing(buffer_ctx, ctx))
+ cleanCache();
+
+ buffer_ctx = ctx;
+
+ quint64 hash_val = 0;
+
+ QGradientStops stops = gradient.stops();
+ for (int i = 0; i < stops.size() && i <= 2; i++)
+ hash_val += stops[i].second.rgba();
+
+ QGLGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
+
+ if (it == cache.constEnd())
+ return addCacheElement(hash_val, gradient, opacity);
+ else {
+ do {
+ const CacheInfo &cache_info = it.value();
+ if (cache_info.stops == stops && cache_info.opacity == opacity && cache_info.interpolationMode == gradient.interpolationMode()) {
+ return cache_info.texId;
+ }
+ ++it;
+ } while (it != cache.constEnd() && it.key() == hash_val);
+ // an exact match for these stops and opacity was not found, create new cache
+ return addCacheElement(hash_val, gradient, opacity);
+ }
+ }
+
+ inline int paletteSize() const { return 1024; }
+
+protected:
+ inline int maxCacheSize() const { return 60; }
+ inline void generateGradientColorTable(const QGradient& g,
+ uint *colorTable,
+ int size, qreal opacity) const;
+ GLuint addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity) {
+ if (cache.size() == maxCacheSize()) {
+ int elem_to_remove = qrand() % maxCacheSize();
+ quint64 key = cache.keys()[elem_to_remove];
+
+ // need to call glDeleteTextures on each removed cache entry:
+ QGLGradientColorTableHash::const_iterator it = cache.constFind(key);
+ do {
+ glDeleteTextures(1, &it.value().texId);
+ } while (++it != cache.constEnd() && it.key() == key);
+ cache.remove(key); // may remove more than 1, but OK
+ }
+ CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
+ uint buffer[1024];
+ generateGradientColorTable(gradient, buffer, paletteSize(), opacity);
+ glGenTextures(1, &cache_entry.texId);
+#ifndef QT_OPENGL_ES
+ glBindTexture(GL_TEXTURE_1D, cache_entry.texId);
+ glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, paletteSize(),
+ 0, GL_BGRA, GL_UNSIGNED_BYTE, buffer);
+#else
+ // create 2D one-line texture instead. This requires an impl of manual GL_TEXGEN for all primitives
+#endif
+ return cache.insert(hash_val, cache_entry).value().texId;
+ }
+
+ void cleanCache() {
+ QGLShareContextScope scope(buffer_ctx);
+ QGLGradientColorTableHash::const_iterator it = cache.constBegin();
+ for (; it != cache.constEnd(); ++it) {
+ const CacheInfo &cache_info = it.value();
+ glDeleteTextures(1, &cache_info.texId);
+ }
+ cache.clear();
+ }
+
+ QGLGradientColorTableHash cache;
+
+ QGLContext *buffer_ctx;
+
+public Q_SLOTS:
+ void cleanupGLContextRefs(const QGLContext *context) {
+ if (context == buffer_ctx) {
+ cleanCache();
+ buffer_ctx = 0;
+ }
+ }
+};
+
+static inline uint endianColor(uint c)
+{
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+ return c;
+#else
+ return ( (c << 24) & 0xff000000)
+ | ((c >> 24) & 0x000000ff)
+ | ((c << 8) & 0x00ff0000)
+ | ((c >> 8) & 0x0000ff00);
+#endif // Q_BYTE_ORDER
+}
+
+void QGLGradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, qreal opacity) const
+{
+ int pos = 0;
+ QGradientStops s = gradient.stops();
+ QVector<uint> colors(s.size());
+
+ for (int i = 0; i < s.size(); ++i)
+ colors[i] = s[i].second.rgba();
+
+ bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
+
+ uint alpha = qRound(opacity * 256);
+ uint current_color = ARGB_COMBINE_ALPHA(colors[0], alpha);
+ qreal incr = 1.0 / qreal(size);
+ qreal fpos = 1.5 * incr;
+ colorTable[pos++] = endianColor(PREMUL(current_color));
+
+ while (fpos <= s.first().first) {
+ colorTable[pos] = colorTable[pos - 1];
+ pos++;
+ fpos += incr;
+ }
+
+ if (colorInterpolation)
+ current_color = PREMUL(current_color);
+
+ for (int i = 0; i < s.size() - 1; ++i) {
+ qreal delta = 1/(s[i+1].first - s[i].first);
+ uint next_color = ARGB_COMBINE_ALPHA(colors[i+1], alpha);
+ if (colorInterpolation)
+ next_color = PREMUL(next_color);
+
+ while (fpos < s[i+1].first && pos < size) {
+ int dist = int(256 * ((fpos - s[i].first) * delta));
+ int idist = 256 - dist;
+ if (colorInterpolation)
+ colorTable[pos] = endianColor(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
+ else
+ colorTable[pos] = endianColor(PREMUL(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist)));
+ ++pos;
+ fpos += incr;
+ }
+ current_color = next_color;
+ }
+
+ Q_ASSERT(s.size() > 0);
+
+ uint last_color = endianColor(PREMUL(ARGB_COMBINE_ALPHA(colors[s.size() - 1], alpha)));
+ for (;pos < size; ++pos)
+ colorTable[pos] = last_color;
+
+ // Make sure the last color stop is represented at the end of the table
+ colorTable[size-1] = last_color;
+}
+
+#ifndef Q_WS_QWS
+Q_GLOBAL_STATIC(QGLGradientCache, qt_opengl_gradient_cache)
+#endif
+
+void QOpenGLPaintEnginePrivate::createGradientPaletteTexture(const QGradient& g)
+{
+#ifdef QT_OPENGL_ES //###
+ Q_UNUSED(g);
+#else
+ GLuint texId = qt_opengl_gradient_cache()->getBuffer(g, opacity, device->context());
+ glBindTexture(GL_TEXTURE_1D, texId);
+ grad_palette = texId;
+ if (g.spread() == QGradient::RepeatSpread || g.type() == QGradient::ConicalGradient)
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ else if (g.spread() == QGradient::ReflectSpread)
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT_IBM);
+ else
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+#endif
+}
+
+
+inline void QOpenGLPaintEnginePrivate::setGradientOps(const QBrush &brush, const QRectF &bounds)
+{
+ current_style = brush.style();
+
+ if (current_style < Qt::LinearGradientPattern || current_style > Qt::ConicalGradientPattern) {
+ setGLBrush(brush.color());
+ qt_glColor4ubv(brush_color);
+ }
+
+ updateGradient(brush, bounds);
+
+#ifndef QT_OPENGL_ES //### GLES does not have GL_TEXTURE_GEN_ so we are falling back for gradients
+ glDisable(GL_TEXTURE_GEN_S);
+ glDisable(GL_TEXTURE_1D);
+
+ if (current_style == Qt::LinearGradientPattern) {
+ if (high_quality_antialiasing || !has_fast_composition_mode) {
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_LINEAR;
+ } else {
+ glEnable(GL_TEXTURE_GEN_S);
+ glEnable(GL_TEXTURE_1D);
+ }
+ } else {
+ if (use_fragment_programs) {
+ if (current_style == Qt::RadialGradientPattern)
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_RADIAL;
+ else if (current_style == Qt::ConicalGradientPattern)
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_CONICAL;
+ else if (current_style == Qt::SolidPattern)
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_SOLID;
+ else if (current_style == Qt::TexturePattern && !brush.texture().isQBitmap())
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_TEXTURE;
+ else
+ fragment_brush = FRAGMENT_PROGRAM_BRUSH_PATTERN;
+ }
+ }
+#endif
+}
+
+QOpenGLPaintEngine::QOpenGLPaintEngine()
+ : QPaintEngineEx(*(new QOpenGLPaintEnginePrivate))
+{
+}
+
+QOpenGLPaintEngine::~QOpenGLPaintEngine()
+{
+}
+
+bool QOpenGLPaintEngine::begin(QPaintDevice *pdev)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (pdev->devType() == QInternal::OpenGL)
+ d->device = static_cast<QGLPaintDevice*>(pdev);
+ else
+ d->device = QGLPaintDevice::getDevice(pdev);
+
+ if (!d->device)
+ return false;
+
+ d->offscreen.setDevice(pdev);
+ d->has_fast_pen = false;
+ d->inverseScale = 1;
+ d->opacity = 1;
+ d->device->beginPaint();
+ d->matrix = QTransform();
+ d->has_antialiasing = false;
+ d->high_quality_antialiasing = false;
+
+ QSize sz(d->device->size());
+ d->dirty_stencil = QRect(0, 0, sz.width(), sz.height());
+
+ d->use_emulation = false;
+
+ for (int i = 0; i < 4; ++i)
+ for (int j = 0; j < 4; ++j)
+ d->mv_matrix[i][j] = (i == j ? qreal(1) : qreal(0));
+
+ bool has_frag_program = (QGLExtensions::glExtensions & QGLExtensions::FragmentProgram)
+ && (pdev->devType() != QInternal::Pixmap);
+
+ QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
+ if (!ctx) {
+ qWarning() << "QOpenGLPaintEngine: paint device doesn't have a valid GL context.";
+ return false;
+ }
+
+ if (has_frag_program)
+ has_frag_program = qt_resolve_frag_program_extensions(ctx) && qt_resolve_version_1_3_functions(ctx);
+
+ d->use_stencil_method = d->device->format().stencil()
+ && (QGLExtensions::glExtensions & QGLExtensions::StencilWrap);
+ if (d->device->format().directRendering()
+ && (d->use_stencil_method && QGLExtensions::glExtensions & QGLExtensions::StencilTwoSide))
+ d->has_stencil_face_ext = qt_resolve_stencil_face_extension(ctx);
+
+#ifndef QT_OPENGL_ES
+ if (!ctx->d_ptr->internal_context) {
+ glGetDoublev(GL_PROJECTION_MATRIX, &d->projection_matrix[0][0]);
+ glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
+ glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+ glDisableClientState(GL_EDGE_FLAG_ARRAY);
+ glDisableClientState(GL_INDEX_ARRAY);
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+ glDisable(GL_TEXTURE_1D);
+ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ glPixelTransferi(GL_MAP_COLOR, false);
+ glPixelTransferi(GL_MAP_STENCIL, false);
+ glDisable(GL_TEXTURE_GEN_S);
+
+ glPixelStorei(GL_PACK_SWAP_BYTES, false);
+ glPixelStorei(GL_PACK_LSB_FIRST, false);
+ glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_PACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+ glPixelStorei(GL_PACK_ALIGNMENT, 4);
+
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, false);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, false);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+
+ if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2) {
+ glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
+ glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
+ glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
+ glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
+ }
+ }
+#endif
+
+ if (!ctx->d_ptr->internal_context) {
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glMatrixMode(GL_TEXTURE);
+ glPushMatrix();
+ glLoadIdentity();
+ glDisableClientState(GL_COLOR_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+ glDisable(GL_MULTISAMPLE);
+ glDisable(GL_TEXTURE_2D);
+ if (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+ glDisable(GL_TEXTURE_RECTANGLE_NV);
+ glDisable(GL_STENCIL_TEST);
+ glDisable(GL_CULL_FACE);
+ glDisable(GL_LIGHTING);
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ }
+
+ d->offscreen.begin();
+
+ glViewport(0, 0, sz.width(), sz.height()); // XXX (Embedded): We need a solution for GLWidgets that draw in a part or a bigger surface...
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+#ifdef QT_OPENGL_ES
+ glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);
+#else
+ glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
+#endif
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glEnable(GL_BLEND);
+ d->composition_mode = QPainter::CompositionMode_SourceOver;
+
+#ifdef QT_OPENGL_ES
+ d->max_texture_size = ctx->d_func()->maxTextureSize();
+#else
+ bool shared_ctx = QGLContext::areSharing(d->device->context(), d->shader_ctx);
+
+ if (shared_ctx) {
+ d->max_texture_size = d->shader_ctx->d_func()->maxTextureSize();
+ } else {
+ d->max_texture_size = ctx->d_func()->maxTextureSize();
+
+ if (d->shader_ctx) {
+ d->shader_ctx->makeCurrent();
+ glBindTexture(GL_TEXTURE_1D, 0);
+ glDeleteTextures(1, &d->grad_palette);
+
+ if (has_frag_program && d->use_fragment_programs)
+ glDeleteTextures(1, &d->drawable_texture);
+ ctx->makeCurrent();
+ }
+ d->shader_ctx = d->device->context();
+ glGenTextures(1, &d->grad_palette);
+
+ qt_mask_texture_cache()->clearCache();
+ d->use_fragment_programs = has_frag_program;
+ }
+
+ if (d->use_fragment_programs && (!shared_ctx || sz.width() > d->drawable_texture_size.width()
+ || sz.height() > d->drawable_texture_size.height()))
+ {
+ // delete old texture if size has increased, otherwise it was deleted earlier
+ if (shared_ctx)
+ glDeleteTextures(1, &d->drawable_texture);
+
+ d->dirty_drawable_texture = true;
+ d->drawable_texture_size = QSize(qt_next_power_of_two(sz.width()),
+ qt_next_power_of_two(sz.height()));
+ }
+#endif
+
+ updateClipRegion(QRegion(), Qt::NoClip);
+ penChanged();
+ brushChanged();
+ opacityChanged();
+ compositionModeChanged();
+ renderHintsChanged();
+ transformChanged();
+ return true;
+}
+
+bool QOpenGLPaintEngine::end()
+{
+ Q_D(QOpenGLPaintEngine);
+ d->flushDrawQueue();
+ d->offscreen.end();
+ QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
+ if (!ctx->d_ptr->internal_context) {
+ glMatrixMode(GL_TEXTURE);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ }
+#ifndef QT_OPENGL_ES
+ if (ctx->d_ptr->internal_context) {
+ glDisable(GL_SCISSOR_TEST);
+ } else {
+ glMatrixMode(GL_PROJECTION);
+ glLoadMatrixd(&d->projection_matrix[0][0]);
+ glPopAttrib();
+ glPopClientAttrib();
+ }
+#endif
+ d->device->endPaint();
+ qt_mask_texture_cache()->maintainCache();
+
+ return true;
+}
+
+void QOpenGLPaintEngine::updateState(const QPaintEngineState &state)
+{
+ Q_D(QOpenGLPaintEngine);
+ QPaintEngine::DirtyFlags flags = state.state();
+
+ bool update_fast_pen = false;
+
+ if (flags & DirtyOpacity) {
+ update_fast_pen = true;
+ d->opacity = state.opacity();
+ if (d->opacity > 1.0f)
+ d->opacity = 1.0f;
+ if (d->opacity < 0.f)
+ d->opacity = 0.f;
+ // force update
+ flags |= DirtyPen;
+ flags |= DirtyBrush;
+ }
+
+ if (flags & DirtyTransform) {
+ update_fast_pen = true;
+ updateMatrix(state.transform());
+ // brush setup depends on transform state
+ if (state.brush().style() != Qt::NoBrush)
+ flags |= DirtyBrush;
+ }
+
+ if (flags & DirtyPen) {
+ update_fast_pen = true;
+ updatePen(state.pen());
+ }
+
+ if (flags & (DirtyBrush | DirtyBrushOrigin)) {
+ updateBrush(state.brush(), state.brushOrigin());
+ }
+
+ if (flags & DirtyFont) {
+ updateFont(state.font());
+ }
+
+ if (state.state() & DirtyClipEnabled) {
+ if (state.isClipEnabled())
+ updateClipRegion(painter()->clipRegion(), Qt::ReplaceClip);
+ else
+ updateClipRegion(QRegion(), Qt::NoClip);
+ }
+
+ if (flags & DirtyClipPath) {
+ updateClipRegion(QRegion(state.clipPath().toFillPolygon().toPolygon(),
+ state.clipPath().fillRule()),
+ state.clipOperation());
+ }
+
+ if (flags & DirtyClipRegion) {
+ updateClipRegion(state.clipRegion(), state.clipOperation());
+ }
+
+ if (flags & DirtyHints) {
+ updateRenderHints(state.renderHints());
+ }
+
+ if (flags & DirtyCompositionMode) {
+ updateCompositionMode(state.compositionMode());
+ }
+
+ if (update_fast_pen) {
+ Q_D(QOpenGLPaintEngine);
+ qreal pen_width = d->cpen.widthF();
+ d->has_fast_pen =
+ ((pen_width == 0 || (pen_width <= 1 && d->txop <= QTransform::TxTranslate))
+ || d->cpen.isCosmetic())
+ && d->cpen.style() == Qt::SolidLine
+ && d->cpen.isSolid();
+ }
+}
+
+
+void QOpenGLPaintEnginePrivate::setInvMatrixData(const QTransform &inv_matrix)
+{
+ inv_matrix_data[0][0] = inv_matrix.m11();
+ inv_matrix_data[1][0] = inv_matrix.m21();
+ inv_matrix_data[2][0] = inv_matrix.m31();
+
+ inv_matrix_data[0][1] = inv_matrix.m12();
+ inv_matrix_data[1][1] = inv_matrix.m22();
+ inv_matrix_data[2][1] = inv_matrix.m32();
+
+ inv_matrix_data[0][2] = inv_matrix.m13();
+ inv_matrix_data[1][2] = inv_matrix.m23();
+ inv_matrix_data[2][2] = inv_matrix.m33();
+}
+
+
+void QOpenGLPaintEnginePrivate::updateGradient(const QBrush &brush, const QRectF &)
+{
+#ifdef QT_OPENGL_ES
+ Q_UNUSED(brush);
+#else
+ bool has_mirrored_repeat = QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat;
+ Qt::BrushStyle style = brush.style();
+
+ QTransform m = brush.transform();
+
+ if (has_mirrored_repeat && style == Qt::LinearGradientPattern) {
+ const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
+ QTransform m = brush.transform();
+ QPointF realStart = g->start();
+ QPointF realFinal = g->finalStop();
+ QPointF start = m.map(realStart);
+ QPointF stop;
+
+ if (qFuzzyCompare(m.m11(), m.m22()) && m.m12() == 0.0 && m.m21() == 0.0) {
+ // It is a simple uniform scale and/or translation
+ stop = m.map(realFinal);
+ } else {
+ // It is not enough to just transform the endpoints.
+ // We have to make sure the _pattern_ is transformed correctly.
+
+ qreal odx = realFinal.x() - realStart.x();
+ qreal ody = realFinal.y() - realStart.y();
+
+ // nx, ny and dx, dy are normal and gradient direction after transform:
+ qreal nx = m.m11()*ody - m.m21()*odx;
+ qreal ny = m.m12()*ody - m.m22()*odx;
+
+ qreal dx = m.m11()*odx + m.m21()*ody;
+ qreal dy = m.m12()*odx + m.m22()*ody;
+
+ qreal lx = 1 / (dx - dy*nx/ny);
+ qreal ly = 1 / (dy - dx*ny/nx);
+ qreal l = 1 / qSqrt(lx*lx+ly*ly);
+
+ stop = start + QPointF(-ny, nx) * l/qSqrt(nx*nx+ny*ny);
+ }
+
+ float tr[4], f;
+ tr[0] = stop.x() - start.x();
+ tr[1] = stop.y() - start.y();
+ f = 1.0 / (tr[0]*tr[0] + tr[1]*tr[1]);
+ tr[0] *= f;
+ tr[1] *= f;
+ tr[2] = 0;
+ tr[3] = -(start.x()*tr[0] + start.y()*tr[1]);
+ brush_color[0] = brush_color[1] = brush_color[2] = brush_color[3] = 255;
+ qt_glColor4ubv(brush_color);
+ glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+ glTexGenfv(GL_S, GL_OBJECT_PLANE, tr);
+ }
+
+ if (use_fragment_programs) {
+ if (style == Qt::RadialGradientPattern) {
+ const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
+ QPointF realCenter = g->center();
+ QPointF realFocal = g->focalPoint();
+ qreal realRadius = g->radius();
+ QTransform translate(1, 0, 0, 1, -realFocal.x(), -realFocal.y());
+ QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
+ QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
+ QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
+
+ setInvMatrixData(inv_matrix);
+
+ fmp_data[0] = realCenter.x() - realFocal.x();
+ fmp_data[1] = realCenter.y() - realFocal.y();
+
+ fmp2_m_radius2_data[0] = -fmp_data[0] * fmp_data[0] - fmp_data[1] * fmp_data[1] + realRadius * realRadius;
+ } else if (style == Qt::ConicalGradientPattern) {
+ const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
+ QPointF realCenter = g->center();
+ QTransform translate(1, 0, 0, 1, -realCenter.x(), -realCenter.y());
+ QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
+ QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
+ QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
+
+ setInvMatrixData(inv_matrix);
+
+ angle_data[0] = -(g->angle() * 2 * Q_PI) / 360.0;
+ } else if (style == Qt::LinearGradientPattern) {
+ const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
+
+ QPointF realStart = g->start();
+ QPointF realFinal = g->finalStop();
+ QTransform translate(1, 0, 0, 1, -realStart.x(), -realStart.y());
+ QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
+ QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
+ QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted() * translate;
+
+ setInvMatrixData(inv_matrix);
+
+ QPointF l = realFinal - realStart;
+
+ linear_data[0] = l.x();
+ linear_data[1] = l.y();
+
+ linear_data[2] = 1.0f / (l.x() * l.x() + l.y() * l.y());
+ } else if (style != Qt::SolidPattern) {
+ QTransform gl_to_qt(1, 0, 0, -1, 0, pdev->height());
+ QTransform m = QTransform(matrix).translate(brush_origin.x(), brush_origin.y());
+ QTransform inv_matrix = gl_to_qt * (brush.transform() * m).inverted();
+
+ setInvMatrixData(inv_matrix);
+ }
+ }
+
+ if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
+ createGradientPaletteTexture(*brush.gradient());
+ }
+#endif
+}
+
+
+class QOpenGLTessellator : public QTessellator
+{
+public:
+ QOpenGLTessellator() {}
+ ~QOpenGLTessellator() { }
+ QGLTrapezoid toGLTrapezoid(const Trapezoid &trap);
+};
+
+QGLTrapezoid QOpenGLTessellator::toGLTrapezoid(const Trapezoid &trap)
+{
+ QGLTrapezoid t;
+
+ t.top = Q27Dot5ToDouble(trap.top);
+ t.bottom = Q27Dot5ToDouble(trap.bottom);
+
+ Q27Dot5 y = trap.topLeft->y - trap.bottomLeft->y;
+
+ qreal topLeftY = Q27Dot5ToDouble(trap.topLeft->y);
+
+ qreal tx = Q27Dot5ToDouble(trap.topLeft->x);
+ qreal m = (-tx + Q27Dot5ToDouble(trap.bottomLeft->x)) / Q27Dot5ToDouble(y);
+ t.topLeftX = tx + m * (topLeftY - t.top);
+ t.bottomLeftX = tx + m * (topLeftY - t.bottom);
+
+ y = trap.topRight->y - trap.bottomRight->y;
+
+ qreal topRightY = Q27Dot5ToDouble(trap.topRight->y);
+
+ tx = Q27Dot5ToDouble(trap.topRight->x);
+ m = (-tx + Q27Dot5ToDouble(trap.bottomRight->x)) / Q27Dot5ToDouble(y);
+
+ t.topRightX = tx + m * (topRightY - Q27Dot5ToDouble(trap.top));
+ t.bottomRightX = tx + m * (topRightY - Q27Dot5ToDouble(trap.bottom));
+
+ return t;
+}
+
+class QOpenGLImmediateModeTessellator : public QOpenGLTessellator
+{
+public:
+ void addTrap(const Trapezoid &trap);
+ void tessellate(const QPointF *points, int nPoints, bool winding) {
+ trapezoids.reserve(trapezoids.size() + nPoints);
+ setWinding(winding);
+ QTessellator::tessellate(points, nPoints);
+ }
+
+ QVector<QGLTrapezoid> trapezoids;
+};
+
+void QOpenGLImmediateModeTessellator::addTrap(const Trapezoid &trap)
+{
+ trapezoids.append(toGLTrapezoid(trap));
+}
+
+#ifndef QT_OPENGL_ES
+static void drawTrapezoid(const QGLTrapezoid &trap, const qreal offscreenHeight, QGLContext *ctx)
+{
+ qreal minX = qMin(trap.topLeftX, trap.bottomLeftX);
+ qreal maxX = qMax(trap.topRightX, trap.bottomRightX);
+
+ if (qFuzzyCompare(trap.top, trap.bottom) || qFuzzyCompare(minX, maxX) ||
+ (qFuzzyCompare(trap.topLeftX, trap.topRightX) && qFuzzyCompare(trap.bottomLeftX, trap.bottomRightX)))
+ return;
+
+ const qreal xpadding = 1.0;
+ const qreal ypadding = 1.0;
+
+ qreal topDist = offscreenHeight - trap.top;
+ qreal bottomDist = offscreenHeight - trap.bottom;
+
+ qreal reciprocal = bottomDist / (bottomDist - topDist);
+
+ qreal leftB = trap.bottomLeftX + (trap.topLeftX - trap.bottomLeftX) * reciprocal;
+ qreal rightB = trap.bottomRightX + (trap.topRightX - trap.bottomRightX) * reciprocal;
+
+ const bool topZero = qFuzzyIsNull(topDist);
+
+ reciprocal = topZero ? 1.0 / bottomDist : 1.0 / topDist;
+
+ qreal leftA = topZero ? (trap.bottomLeftX - leftB) * reciprocal : (trap.topLeftX - leftB) * reciprocal;
+ qreal rightA = topZero ? (trap.bottomRightX - rightB) * reciprocal : (trap.topRightX - rightB) * reciprocal;
+
+ qreal invLeftA = qFuzzyIsNull(leftA) ? 0.0 : 1.0 / leftA;
+ qreal invRightA = qFuzzyIsNull(rightA) ? 0.0 : 1.0 / rightA;
+
+ // fragment program needs the negative of invRightA as it mirrors the line
+ glTexCoord4f(topDist, bottomDist, invLeftA, -invRightA);
+ glMultiTexCoord4f(GL_TEXTURE1, leftA, leftB, rightA, rightB);
+
+ qreal topY = trap.top - ypadding;
+ qreal bottomY = trap.bottom + ypadding;
+
+ qreal bounds_bottomLeftX = leftA * (offscreenHeight - bottomY) + leftB;
+ qreal bounds_bottomRightX = rightA * (offscreenHeight - bottomY) + rightB;
+ qreal bounds_topLeftX = leftA * (offscreenHeight - topY) + leftB;
+ qreal bounds_topRightX = rightA * (offscreenHeight - topY) + rightB;
+
+ QPointF leftNormal(1, -leftA);
+ leftNormal /= qSqrt(leftNormal.x() * leftNormal.x() + leftNormal.y() * leftNormal.y());
+ QPointF rightNormal(1, -rightA);
+ rightNormal /= qSqrt(rightNormal.x() * rightNormal.x() + rightNormal.y() * rightNormal.y());
+
+ qreal left_padding = xpadding / qAbs(leftNormal.x());
+ qreal right_padding = xpadding / qAbs(rightNormal.x());
+
+ glVertex2d(bounds_topLeftX - left_padding, topY);
+ glVertex2d(bounds_topRightX + right_padding, topY);
+ glVertex2d(bounds_bottomRightX + right_padding, bottomY);
+ glVertex2d(bounds_bottomLeftX - left_padding, bottomY);
+
+ glTexCoord4f(0.0f, 0.0f, 0.0f, 1.0f);
+}
+#endif // !Q_WS_QWS
+
+class QOpenGLTrapezoidToArrayTessellator : public QOpenGLTessellator
+{
+public:
+ QOpenGLTrapezoidToArrayTessellator() : vertices(0), allocated(0), size(0) {}
+ ~QOpenGLTrapezoidToArrayTessellator() { free(vertices); }
+ q_vertexType *vertices;
+ int allocated;
+ int size;
+ QRectF bounds;
+ void addTrap(const Trapezoid &trap);
+ void tessellate(const QPointF *points, int nPoints, bool winding) {
+ size = 0;
+ setWinding(winding);
+ bounds = QTessellator::tessellate(points, nPoints);
+ }
+};
+
+void QOpenGLTrapezoidToArrayTessellator::addTrap(const Trapezoid &trap)
+{
+ // On OpenGL ES we convert the trap to 2 triangles
+#ifndef QT_OPENGL_ES
+ if (size > allocated - 8) {
+#else
+ if (size > allocated - 12) {
+#endif
+ allocated = qMax(2*allocated, 512);
+ vertices = (q_vertexType *)realloc(vertices, allocated * sizeof(q_vertexType));
+ }
+
+ QGLTrapezoid t = toGLTrapezoid(trap);
+
+#ifndef QT_OPENGL_ES
+ vertices[size++] = f2vt(t.topLeftX);
+ vertices[size++] = f2vt(t.top);
+ vertices[size++] = f2vt(t.topRightX);
+ vertices[size++] = f2vt(t.top);
+ vertices[size++] = f2vt(t.bottomRightX);
+ vertices[size++] = f2vt(t.bottom);
+ vertices[size++] = f2vt(t.bottomLeftX);
+ vertices[size++] = f2vt(t.bottom);
+#else
+ // First triangle
+ vertices[size++] = f2vt(t.topLeftX);
+ vertices[size++] = f2vt(t.top);
+ vertices[size++] = f2vt(t.topRightX);
+ vertices[size++] = f2vt(t.top);
+ vertices[size++] = f2vt(t.bottomRightX);
+ vertices[size++] = f2vt(t.bottom);
+
+ // Second triangle
+ vertices[size++] = f2vt(t.bottomLeftX);
+ vertices[size++] = f2vt(t.bottom);
+ vertices[size++] = f2vt(t.topLeftX);
+ vertices[size++] = f2vt(t.top);
+ vertices[size++] = f2vt(t.bottomRightX);
+ vertices[size++] = f2vt(t.bottom);
+#endif
+}
+
+
+void QOpenGLPaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
+ Qt::FillRule fill)
+{
+ QOpenGLTrapezoidToArrayTessellator tessellator;
+ tessellator.tessellate(polygonPoints, pointCount, fill == Qt::WindingFill);
+
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon with" << pointCount << "points using fillPolygon_dev";
+
+ setGradientOps(cbrush, tessellator.bounds);
+
+ bool fast_style = current_style == Qt::LinearGradientPattern
+ || current_style == Qt::SolidPattern;
+
+#ifndef QT_OPENGL_ES
+ GLenum geometry_mode = GL_QUADS;
+#else
+ GLenum geometry_mode = GL_TRIANGLES;
+#endif
+
+ if (use_fragment_programs && !(fast_style && has_fast_composition_mode)) {
+ composite(geometry_mode, tessellator.vertices, tessellator.size / 2);
+ } else {
+ glVertexPointer(2, q_vertexTypeEnum, 0, tessellator.vertices);
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glDrawArrays(geometry_mode, 0, tessellator.size/2);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ }
+}
+
+
+inline void QOpenGLPaintEnginePrivate::lineToStencil(qreal x, qreal y)
+{
+ tess_points.add(QPointF(x, y));
+
+ if (x > max_x)
+ max_x = x;
+ else if (x < min_x)
+ min_x = x;
+ if (y > max_y)
+ max_y = y;
+ else if (y < min_y)
+ min_y = y;
+}
+
+inline void QOpenGLPaintEnginePrivate::curveToStencil(const QPointF &cp1, const QPointF &cp2, const QPointF &ep)
+{
+ qreal inverseScaleHalf = inverseScale / 2;
+
+ QBezier beziers[32];
+ beziers[0] = QBezier::fromPoints(tess_points.last(), cp1, cp2, ep);
+ QBezier *b = beziers;
+ while (b >= beziers) {
+ // check if we can pop the top bezier curve from the stack
+ qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
+ qreal d;
+ if (l > inverseScale) {
+ d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2) - (b->y4 - b->y1)*(b->x1 - b->x2) )
+ + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3) - (b->y4 - b->y1)*(b->x1 - b->x3) );
+ d /= l;
+ } else {
+ d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
+ qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
+ }
+ if (d < inverseScaleHalf || b == beziers + 31) {
+ // good enough, we pop it off and add the endpoint
+ lineToStencil(b->x4, b->y4);
+ --b;
+ } else {
+ // split, second half of the polygon goes lower into the stack
+ b->split(b+1, b);
+ ++b;
+ }
+ }
+}
+
+
+void QOpenGLPaintEnginePrivate::pathToVertexArrays(const QPainterPath &path)
+{
+ const QPainterPath::Element &first = path.elementAt(0);
+ min_x = max_x = first.x;
+ min_y = max_y = first.y;
+
+ tess_points.reset();
+ tess_points_stops.clear();
+ lineToStencil(first.x, first.y);
+
+ for (int i=1; i<path.elementCount(); ++i) {
+ const QPainterPath::Element &e = path.elementAt(i);
+ switch (e.type) {
+ case QPainterPath::MoveToElement:
+ tess_points_stops.append(tess_points.size());
+ lineToStencil(e.x, e.y);
+ break;
+ case QPainterPath::LineToElement:
+ lineToStencil(e.x, e.y);
+ break;
+ case QPainterPath::CurveToElement:
+ curveToStencil(e, path.elementAt(i+1), path.elementAt(i+2));
+ i+=2;
+ break;
+ default:
+ break;
+ }
+ }
+ lineToStencil(first.x, first.y);
+ tess_points_stops.append(tess_points.size());
+}
+
+
+void QOpenGLPaintEnginePrivate::drawVertexArrays()
+{
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(2, GL_DOUBLE, 0, tess_points.data());
+ int previous_stop = 0;
+ foreach(int stop, tess_points_stops) {
+ glDrawArrays(GL_TRIANGLE_FAN, previous_stop, stop-previous_stop);
+ previous_stop = stop;
+ }
+ glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void QOpenGLPaintEnginePrivate::fillVertexArray(Qt::FillRule fillRule)
+{
+ Q_Q(QOpenGLPaintEngine);
+
+ QRect rect = dirty_stencil.boundingRect();
+
+ if (use_system_clip)
+ rect = q->systemClip().intersected(dirty_stencil).boundingRect();
+
+ glStencilMask(~0);
+
+ if (!rect.isEmpty()) {
+ disableClipping();
+
+ glEnable(GL_SCISSOR_TEST);
+
+ const int left = rect.left();
+ const int width = rect.width();
+ const int bottom = device->size().height() - (rect.bottom() + 1);
+ const int height = rect.height();
+
+ glScissor(left, bottom, width, height);
+
+ glClearStencil(0);
+ glClear(GL_STENCIL_BUFFER_BIT);
+ dirty_stencil -= rect;
+
+ glDisable(GL_SCISSOR_TEST);
+
+ enableClipping();
+ }
+
+ // Enable stencil.
+ glEnable(GL_STENCIL_TEST);
+
+ // Disable color writes.
+ glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+ GLuint stencilMask = 0;
+
+ if (fillRule == Qt::OddEvenFill) {
+ stencilMask = 1;
+
+ // Enable stencil writes.
+ glStencilMask(stencilMask);
+
+ // Set stencil xor mode.
+ glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
+
+ // Disable stencil func.
+ glStencilFunc(GL_ALWAYS, 0, ~0);
+
+ drawVertexArrays();
+ } else if (fillRule == Qt::WindingFill) {
+ stencilMask = ~0;
+
+ if (has_stencil_face_ext) {
+ QGL_FUNC_CONTEXT;
+ glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
+
+ glActiveStencilFaceEXT(GL_BACK);
+ glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
+ glStencilFunc(GL_ALWAYS, 0, ~0);
+
+ glActiveStencilFaceEXT(GL_FRONT);
+ glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
+ glStencilFunc(GL_ALWAYS, 0, ~0);
+
+ drawVertexArrays();
+
+ glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
+ } else {
+ glStencilFunc(GL_ALWAYS, 0, ~0);
+ glEnable(GL_CULL_FACE);
+
+ glCullFace(GL_BACK);
+ glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
+ drawVertexArrays();
+
+ glCullFace(GL_FRONT);
+ glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
+ drawVertexArrays();
+
+ glDisable(GL_CULL_FACE);
+ }
+ }
+
+ // Enable color writes.
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ glStencilMask(stencilMask);
+
+ setGradientOps(cbrush, QRectF(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y)));
+
+ bool fast_fill = has_fast_composition_mode && (current_style == Qt::LinearGradientPattern || current_style == Qt::SolidPattern);
+
+ if (use_fragment_programs && !fast_fill) {
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (fragment programs)";
+ QRectF rect(QPointF(min_x, min_y), QSizeF(max_x - min_x, max_y - min_y));
+
+ // Enable stencil func.
+ glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
+ glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+ composite(rect);
+ } else {
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Drawing polygon using stencil method (no fragment programs)";
+
+ // Enable stencil func.
+ glStencilFunc(GL_NOTEQUAL, 0, stencilMask);
+ glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+#ifndef QT_OPENGL_ES
+ glBegin(GL_QUADS);
+ glVertex2f(min_x, min_y);
+ glVertex2f(max_x, min_y);
+ glVertex2f(max_x, max_y);
+ glVertex2f(min_x, max_y);
+ glEnd();
+#endif
+ }
+
+ // Disable stencil writes.
+ glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+ glStencilMask(0);
+ glDisable(GL_STENCIL_TEST);
+}
+
+void QOpenGLPaintEnginePrivate::fillPath(const QPainterPath &path)
+{
+ if (path.isEmpty())
+ return;
+
+ if (use_stencil_method && !high_quality_antialiasing) {
+ pathToVertexArrays(path);
+ fillVertexArray(path.fillRule());
+ return;
+ }
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ if (high_quality_antialiasing)
+ drawOffscreenPath(path);
+ else {
+ QPolygonF poly = path.toFillPolygon(matrix);
+ fillPolygon_dev(poly.data(), poly.count(),
+ path.fillRule());
+ }
+
+ updateGLMatrix();
+}
+
+
+static inline bool needsEmulation(Qt::BrushStyle style)
+{
+ return !(style == Qt::SolidPattern
+ || (style == Qt::LinearGradientPattern
+ && (QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat)));
+}
+
+void QOpenGLPaintEnginePrivate::updateUseEmulation()
+{
+ use_emulation = !use_fragment_programs
+ && ((has_pen && needsEmulation(pen_brush_style))
+ || (has_brush && needsEmulation(brush_style)));
+}
+
+void QOpenGLPaintEngine::updatePen(const QPen &pen)
+{
+ Q_D(QOpenGLPaintEngine);
+ Qt::PenStyle pen_style = pen.style();
+ d->pen_brush_style = pen.brush().style();
+ d->cpen = pen;
+ d->has_pen = (pen_style != Qt::NoPen) && (d->pen_brush_style != Qt::NoBrush);
+ d->updateUseEmulation();
+
+ if (pen.isCosmetic()) {
+ GLfloat width = pen.widthF() == 0.0f ? 1.0f : pen.widthF();
+ glLineWidth(width);
+ glPointSize(width);
+ }
+
+ if (d->pen_brush_style >= Qt::LinearGradientPattern
+ && d->pen_brush_style <= Qt::ConicalGradientPattern)
+ {
+ d->setGLPen(Qt::white);
+ } else {
+ d->setGLPen(pen.color());
+ }
+
+ d->updateFastPen();
+}
+
+void QOpenGLPaintEngine::updateBrush(const QBrush &brush, const QPointF &origin)
+{
+ Q_D(QOpenGLPaintEngine);
+ d->cbrush = brush;
+ d->brush_style = brush.style();
+ d->brush_origin = origin;
+ d->has_brush = (d->brush_style != Qt::NoBrush);
+ d->updateUseEmulation();
+}
+
+void QOpenGLPaintEngine::updateFont(const QFont &)
+{
+}
+
+void QOpenGLPaintEngine::updateMatrix(const QTransform &mtx)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ d->matrix = mtx;
+
+ d->mv_matrix[0][0] = mtx.m11();
+ d->mv_matrix[0][1] = mtx.m12();
+ d->mv_matrix[0][2] = 0;
+ d->mv_matrix[0][3] = mtx.m13();
+
+ d->mv_matrix[1][0] = mtx.m21();
+ d->mv_matrix[1][1] = mtx.m22();
+ d->mv_matrix[1][2] = 0;
+ d->mv_matrix[1][3] = mtx.m23();
+
+ d->mv_matrix[2][0] = 0;
+ d->mv_matrix[2][1] = 0;
+ d->mv_matrix[2][2] = 1;
+ d->mv_matrix[2][3] = 0;
+
+ d->mv_matrix[3][0] = mtx.dx();
+ d->mv_matrix[3][1] = mtx.dy();
+ d->mv_matrix[3][2] = 0;
+ d->mv_matrix[3][3] = mtx.m33();
+
+ d->txop = mtx.type();
+
+ // 1/10000 == 0.0001, so we have good enough res to cover curves
+ // that span the entire widget...
+ d->inverseScale = qMax(1 / qMax( qMax(qAbs(mtx.m11()), qAbs(mtx.m22())),
+ qMax(qAbs(mtx.m12()), qAbs(mtx.m21())) ),
+ qreal(0.0001));
+
+ d->updateGLMatrix();
+ d->updateFastPen();
+}
+
+void QOpenGLPaintEnginePrivate::updateGLMatrix() const
+{
+ glMatrixMode(GL_MODELVIEW);
+#ifndef QT_OPENGL_ES
+ glLoadMatrixd(&mv_matrix[0][0]);
+#else
+ glLoadMatrixf(&mv_matrix[0][0]);
+#endif
+}
+
+void QOpenGLPaintEnginePrivate::disableClipping()
+{
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_SCISSOR_TEST);
+}
+
+void QOpenGLPaintEnginePrivate::enableClipping()
+{
+ Q_Q(QOpenGLPaintEngine);
+ if (!q->state()->hasClipping)
+ return;
+
+ if (q->state()->fastClip.isEmpty())
+ glEnable(GL_DEPTH_TEST);
+ else
+ updateDepthClip(); // this will enable the scissor test
+}
+
+void QOpenGLPaintEnginePrivate::updateDepthClip()
+{
+ Q_Q(QOpenGLPaintEngine);
+
+ ++q->state()->depthClipId;
+
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_SCISSOR_TEST);
+
+ if (!q->state()->hasClipping)
+ return;
+
+ QRect fastClip;
+ if (q->state()->clipEnabled) {
+ fastClip = q->state()->fastClip;
+ } else if (use_system_clip && q->systemClip().rects().count() == 1) {
+ fastClip = q->systemClip().rects().at(0);
+ }
+
+ if (!fastClip.isEmpty()) {
+ glEnable(GL_SCISSOR_TEST);
+
+ const int left = fastClip.left();
+ const int width = fastClip.width();
+ const int bottom = device->size().height() - (fastClip.bottom() + 1);
+ const int height = fastClip.height();
+
+ glScissor(left, bottom, width, height);
+ return;
+ }
+
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2) || defined(QT_OPENGL_ES_1_CL)
+ glClearDepthf(0.0f);
+#else
+ glClearDepth(0.0f);
+#endif
+
+ glEnable(GL_DEPTH_TEST);
+ glDepthMask(GL_TRUE);
+ glClear(GL_DEPTH_BUFFER_BIT);
+
+ glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+ glDepthFunc(GL_ALWAYS);
+
+ const QVector<QRect> rects = q->state()->clipEnabled ? q->state()->clipRegion.rects() : q->systemClip().rects();
+
+ // rectangle count * 2 (triangles) * vertex count * component count (Z omitted)
+ QDataBuffer<q_vertexType> clipVertex(rects.size()*2*3*2);
+ for (int i = 0; i < rects.size(); ++i) {
+ q_vertexType x = i2vt(rects.at(i).left());
+ q_vertexType w = i2vt(rects.at(i).width());
+ q_vertexType h = i2vt(rects.at(i).height());
+ q_vertexType y = i2vt(rects.at(i).top());
+
+ // First triangle
+ clipVertex.add(x);
+ clipVertex.add(y);
+
+ clipVertex.add(x);
+ clipVertex.add(y + h);
+
+ clipVertex.add(x + w);
+ clipVertex.add(y);
+
+ // Second triangle
+ clipVertex.add(x);
+ clipVertex.add(y + h);
+
+ clipVertex.add(x + w);
+ clipVertex.add(y + h);
+
+ clipVertex.add (x + w);
+ clipVertex.add(y);
+ }
+
+ if (rects.size()) {
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(2, q_vertexTypeEnum, 0, clipVertex.data());
+
+ glDrawArrays(GL_TRIANGLES, 0, rects.size()*2*3);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ updateGLMatrix();
+ }
+
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ glDepthMask(GL_FALSE);
+ glDepthFunc(GL_LEQUAL);
+}
+
+void QOpenGLPaintEnginePrivate::systemStateChanged()
+{
+ Q_Q(QOpenGLPaintEngine);
+ if (q->painter()->hasClipping())
+ q->updateClipRegion(q->painter()->clipRegion(), Qt::ReplaceClip);
+ else
+ q->updateClipRegion(QRegion(), Qt::NoClip);
+}
+
+void QOpenGLPaintEngine::updateClipRegion(const QRegion &clipRegion, Qt::ClipOperation op)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ // clipping is only supported when a stencil or depth buffer is
+ // available
+ if (!d->device->format().depth())
+ return;
+
+ d->use_system_clip = false;
+ QRegion sysClip = systemClip();
+ if (!sysClip.isEmpty()) {
+ if (d->pdev->devType() != QInternal::Widget) {
+ d->use_system_clip = true;
+ } else {
+#ifndef Q_WS_QWS
+ // Only use the system clip if we're currently rendering a widget with a GL painter.
+ if (d->currentClipWidget) {
+ QWidgetPrivate *widgetPrivate = qt_widget_private(d->currentClipWidget->window());
+ d->use_system_clip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
+ }
+#endif
+ }
+ }
+
+ d->flushDrawQueue();
+
+ if (op == Qt::NoClip && !d->use_system_clip) {
+ state()->hasClipping = false;
+ state()->clipRegion = QRegion();
+ d->updateDepthClip();
+ return;
+ }
+
+ bool isScreenClip = false;
+ if (!d->use_system_clip) {
+ QVector<QRect> untransformedRects = clipRegion.rects();
+
+ if (untransformedRects.size() == 1) {
+ QPainterPath path;
+ path.addRect(untransformedRects[0]);
+ path = d->matrix.map(path);
+
+ if (path.contains(QRectF(QPointF(), d->device->size())))
+ isScreenClip = true;
+ }
+ }
+
+ QRegion region = isScreenClip ? QRegion() : clipRegion * d->matrix;
+ switch (op) {
+ case Qt::NoClip:
+ if (!d->use_system_clip)
+ break;
+ state()->clipRegion = sysClip;
+ break;
+ case Qt::IntersectClip:
+ if (isScreenClip)
+ return;
+ if (state()->hasClipping) {
+ state()->clipRegion &= region;
+ break;
+ }
+ // fall through
+ case Qt::ReplaceClip:
+ if (d->use_system_clip)
+ state()->clipRegion = region & sysClip;
+ else
+ state()->clipRegion = region;
+ break;
+ case Qt::UniteClip:
+ state()->clipRegion |= region;
+ if (d->use_system_clip)
+ state()->clipRegion &= sysClip;
+ break;
+ default:
+ break;
+ }
+
+ if (isScreenClip) {
+ state()->hasClipping = false;
+ state()->clipRegion = QRegion();
+ } else {
+ state()->hasClipping = op != Qt::NoClip || d->use_system_clip;
+ }
+
+ if (state()->hasClipping && state()->clipRegion.rects().size() == 1)
+ state()->fastClip = state()->clipRegion.rects().at(0);
+ else
+ state()->fastClip = QRect();
+
+ d->updateDepthClip();
+}
+
+void QOpenGLPaintEngine::updateRenderHints(QPainter::RenderHints hints)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ d->flushDrawQueue();
+ d->use_smooth_pixmap_transform = bool(hints & QPainter::SmoothPixmapTransform);
+ if ((hints & QPainter::Antialiasing) || (hints & QPainter::HighQualityAntialiasing)) {
+ if (d->use_fragment_programs && QGLOffscreen::isSupported()
+ && (hints & QPainter::HighQualityAntialiasing)) {
+ d->high_quality_antialiasing = true;
+ } else {
+ d->high_quality_antialiasing = false;
+ if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+ glEnable(GL_MULTISAMPLE);
+ }
+ } else {
+ d->high_quality_antialiasing = false;
+ if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+ glDisable(GL_MULTISAMPLE);
+ }
+
+ if (d->high_quality_antialiasing) {
+ d->offscreen.initialize();
+
+ if (!d->offscreen.isValid()) {
+ DEBUG_ONCE_STR("Unable to initialize offscreen, disabling high quality antialiasing");
+ d->high_quality_antialiasing = false;
+ if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+ glEnable(GL_MULTISAMPLE);
+ }
+ }
+
+ d->has_antialiasing = d->high_quality_antialiasing
+ || ((hints & QPainter::Antialiasing)
+ && (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers));
+}
+
+
+void QOpenGLPaintEnginePrivate::setPorterDuffData(float a, float b, float x, float y, float z)
+{
+ porterduff_ab_data[0] = a;
+ porterduff_ab_data[1] = b;
+
+ porterduff_xyz_data[0] = x;
+ porterduff_xyz_data[1] = y;
+ porterduff_xyz_data[2] = z;
+}
+
+
+void QOpenGLPaintEngine::updateCompositionMode(QPainter::CompositionMode composition_mode)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (!d->use_fragment_programs && composition_mode > QPainter::CompositionMode_Plus)
+ composition_mode = QPainter::CompositionMode_SourceOver;
+
+ d->composition_mode = composition_mode;
+
+ d->has_fast_composition_mode = (!d->high_quality_antialiasing && composition_mode <= QPainter::CompositionMode_Plus)
+ || composition_mode == QPainter::CompositionMode_SourceOver
+ || composition_mode == QPainter::CompositionMode_Destination
+ || composition_mode == QPainter::CompositionMode_DestinationOver
+ || composition_mode == QPainter::CompositionMode_DestinationOut
+ || composition_mode == QPainter::CompositionMode_SourceAtop
+ || composition_mode == QPainter::CompositionMode_Xor
+ || composition_mode == QPainter::CompositionMode_Plus;
+
+ if (d->has_fast_composition_mode)
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODE_BLEND_MODE_MASK : COMPOSITION_MODE_BLEND_MODE_NOMASK;
+ else if (composition_mode <= QPainter::CompositionMode_Plus)
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SIMPLE_PORTER_DUFF : COMPOSITION_MODES_SIMPLE_PORTER_DUFF_NOMASK;
+ else
+ switch (composition_mode) {
+ case QPainter::CompositionMode_Multiply:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_MULTIPLY : COMPOSITION_MODES_MULTIPLY_NOMASK;
+ break;
+ case QPainter::CompositionMode_Screen:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SCREEN : COMPOSITION_MODES_SCREEN_NOMASK;
+ break;
+ case QPainter::CompositionMode_Overlay:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_OVERLAY : COMPOSITION_MODES_OVERLAY_NOMASK;
+ break;
+ case QPainter::CompositionMode_Darken:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DARKEN : COMPOSITION_MODES_DARKEN_NOMASK;
+ break;
+ case QPainter::CompositionMode_Lighten:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_LIGHTEN : COMPOSITION_MODES_LIGHTEN_NOMASK;
+ break;
+ case QPainter::CompositionMode_ColorDodge:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORDODGE : COMPOSITION_MODES_COLORDODGE_NOMASK;
+ break;
+ case QPainter::CompositionMode_ColorBurn:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_COLORBURN : COMPOSITION_MODES_COLORBURN_NOMASK;
+ break;
+ case QPainter::CompositionMode_HardLight:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_HARDLIGHT : COMPOSITION_MODES_HARDLIGHT_NOMASK;
+ break;
+ case QPainter::CompositionMode_SoftLight:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_SOFTLIGHT : COMPOSITION_MODES_SOFTLIGHT_NOMASK;
+ break;
+ case QPainter::CompositionMode_Difference:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_DIFFERENCE : COMPOSITION_MODES_DIFFERENCE_NOMASK;
+ break;
+ case QPainter::CompositionMode_Exclusion:
+ d->fragment_composition_mode = d->high_quality_antialiasing ? COMPOSITION_MODES_EXCLUSION : COMPOSITION_MODES_EXCLUSION_NOMASK;
+ break;
+ default:
+ Q_ASSERT(false);
+ }
+
+ switch(composition_mode) {
+ case QPainter::CompositionMode_DestinationOver:
+ glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
+ d->setPorterDuffData(0, 1, 1, 1, 1);
+ break;
+ case QPainter::CompositionMode_Clear:
+ glBlendFunc(GL_ZERO, GL_ZERO);
+ d->setPorterDuffData(0, 0, 0, 0, 0);
+ break;
+ case QPainter::CompositionMode_Source:
+ glBlendFunc(GL_ONE, GL_ZERO);
+ d->setPorterDuffData(1, 0, 1, 1, 0);
+ break;
+ case QPainter::CompositionMode_Destination:
+ glBlendFunc(GL_ZERO, GL_ONE);
+ d->setPorterDuffData(0, 1, 1, 0, 1);
+ break;
+ case QPainter::CompositionMode_SourceIn:
+ glBlendFunc(GL_DST_ALPHA, GL_ZERO);
+ d->setPorterDuffData(1, 0, 1, 0, 0);
+ break;
+ case QPainter::CompositionMode_DestinationIn:
+ glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
+ d->setPorterDuffData(0, 1, 1, 0, 0);
+ break;
+ case QPainter::CompositionMode_SourceOut:
+ glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
+ d->setPorterDuffData(0, 0, 0, 1, 0);
+ break;
+ case QPainter::CompositionMode_DestinationOut:
+ glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
+ d->setPorterDuffData(0, 0, 0, 0, 1);
+ break;
+ case QPainter::CompositionMode_SourceAtop:
+ glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ d->setPorterDuffData(1, 0, 1, 0, 1);
+ break;
+ case QPainter::CompositionMode_DestinationAtop:
+ glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
+ d->setPorterDuffData(0, 1, 1, 1, 0);
+ break;
+ case QPainter::CompositionMode_Xor:
+ glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ d->setPorterDuffData(0, 0, 0, 1, 1);
+ break;
+ case QPainter::CompositionMode_SourceOver:
+ glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+ d->setPorterDuffData(1, 0, 1, 1, 1);
+ break;
+ case QPainter::CompositionMode_Plus:
+ glBlendFunc(GL_ONE, GL_ONE);
+ d->setPorterDuffData(1, 1, 1, 1, 1);
+ break;
+ default:
+ break;
+ }
+}
+
+class QGLMaskGenerator
+{
+public:
+ QGLMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal stroke_width = -1)
+ : p(path),
+ m(matrix),
+ w(stroke_width)
+ {
+ }
+
+ virtual QRect screenRect() = 0;
+ virtual void drawMask(const QRect &rect) = 0;
+
+ QPainterPath path() const { return p; }
+ QTransform matrix() const { return m; }
+ qreal strokeWidth() const { return w; }
+
+ virtual ~QGLMaskGenerator() {}
+
+private:
+ QPainterPath p;
+ QTransform m;
+ qreal w;
+};
+
+void QGLMaskTextureCache::setOffscreenSize(const QSize &sz)
+{
+ Q_ASSERT(sz.width() == sz.height());
+
+ if (offscreenSize != sz) {
+ offscreenSize = sz;
+ clearCache();
+ }
+}
+
+void QGLMaskTextureCache::clearCache()
+{
+ cache.clear();
+
+ int quad_tree_size = 1;
+
+ for (int i = block_size; i < offscreenSize.width(); i *= 2)
+ quad_tree_size += quad_tree_size * 4;
+
+ for (int i = 0; i < 4; ++i) {
+ occupied_quadtree[i].resize(quad_tree_size);
+
+ occupied_quadtree[i][0].key = 0;
+ occupied_quadtree[i][0].largest_available_block = offscreenSize.width();
+ occupied_quadtree[i][0].largest_used_block = 0;
+
+ DEBUG_ONCE qDebug() << "QGLMaskTextureCache:: created quad tree of size" << quad_tree_size;
+ }
+}
+
+void QGLMaskTextureCache::setDrawableSize(const QSize &sz)
+{
+ drawableSize = sz;
+}
+
+void QGLMaskTextureCache::maintainCache()
+{
+ QGLTextureCacheHash::iterator it = cache.begin();
+ QGLTextureCacheHash::iterator end = cache.end();
+
+ while (it != end) {
+ CacheInfo &cache_info = it.value();
+ ++cache_info.age;
+
+ if (cache_info.age > 1) {
+ quadtreeInsert(cache_info.loc.channel, 0, cache_info.loc.rect);
+ it = cache.erase(it);
+ } else {
+ ++it;
+ }
+ }
+}
+
+//#define DISABLE_MASK_CACHE
+
+QGLMaskTextureCache::CacheLocation QGLMaskTextureCache::getMask(QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *e)
+{
+#ifndef DISABLE_MASK_CACHE
+ engine = e;
+
+ quint64 key = hash(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());
+
+ if (key == 0)
+ key = 1;
+
+ CacheInfo info(maskGenerator.path(), maskGenerator.matrix(), maskGenerator.strokeWidth());
+
+ QGLTextureCacheHash::iterator it = cache.find(key);
+
+ while (it != cache.end() && it.key() == key) {
+ CacheInfo &cache_info = it.value();
+ if (info.stroke_width == cache_info.stroke_width && info.matrix == cache_info.matrix && info.path == cache_info.path) {
+ DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Using cached mask");
+
+ cache_info.age = 0;
+ return cache_info.loc;
+ }
+ ++it;
+ }
+
+ // mask was not found, create new mask
+
+ DEBUG_ONCE_STR("QGLMaskTextureCache::getMask(): Creating new mask...");
+
+ createMask(key, info, maskGenerator);
+
+ cache.insert(key, info);
+
+ return info.loc;
+#else
+ CacheInfo info(maskGenerator.path(), maskGenerator.matrix());
+ createMask(0, info, maskGenerator);
+ return info.loc;
+#endif
+}
+
+#ifndef FloatToQuint64
+#define FloatToQuint64(i) (quint64)((i) * 32)
+#endif
+
+quint64 QGLMaskTextureCache::hash(const QPainterPath &p, const QTransform &m, qreal w)
+{
+ Q_ASSERT(sizeof(quint64) == 8);
+
+ quint64 h = 0;
+
+ for (int i = 0; i < p.elementCount(); ++i) {
+ h += FloatToQuint64(p.elementAt(i).x) << 32;
+ h += FloatToQuint64(p.elementAt(i).y);
+ h += p.elementAt(i).type;
+ }
+
+ h += FloatToQuint64(m.m11());
+#ifndef Q_OS_WINCE // ###
+ //Compiler crashes for arm on WinCE
+ h += FloatToQuint64(m.m12()) << 4;
+ h += FloatToQuint64(m.m13()) << 8;
+ h += FloatToQuint64(m.m21()) << 12;
+ h += FloatToQuint64(m.m22()) << 16;
+ h += FloatToQuint64(m.m23()) << 20;
+ h += FloatToQuint64(m.m31()) << 24;
+ h += FloatToQuint64(m.m32()) << 28;
+#endif
+ h += FloatToQuint64(m.m33()) << 32;
+
+ h += FloatToQuint64(w);
+
+ return h;
+}
+
+void QGLMaskTextureCache::createMask(quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator)
+{
+ info.loc.screen_rect = maskGenerator.screenRect();
+
+ if (info.loc.screen_rect.isEmpty()) {
+ info.loc.channel = 0;
+ info.loc.rect = QRect();
+ return;
+ }
+
+ quadtreeAllocate(key, info.loc.screen_rect.size(), &info.loc.rect, &info.loc.channel);
+
+ int ch = info.loc.channel;
+ glColorMask(ch == 0, ch == 1, ch == 2, ch == 3);
+
+ maskGenerator.drawMask(info.loc.rect);
+
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+}
+
+int QGLMaskTextureCache::quadtreeBlocksize(int node)
+{
+ DEBUG_ONCE qDebug() << "Offscreen size:" << offscreenSize.width();
+
+ int blocksize = offscreenSize.width();
+
+ while (node) {
+ node = (node - 1) / 4;
+ blocksize /= 2;
+ }
+
+ return blocksize;
+}
+
+QPoint QGLMaskTextureCache::quadtreeLocation(int node)
+{
+ QPoint location;
+ int blocksize = quadtreeBlocksize(node);
+
+ while (node) {
+ --node;
+
+ if (node & 1)
+ location.setX(location.x() + blocksize);
+
+ if (node & 2)
+ location.setY(location.y() + blocksize);
+
+ node /= 4;
+ blocksize *= 2;
+ }
+
+ return location;
+}
+
+void QGLMaskTextureCache::quadtreeUpdate(int channel, int node, int current_block_size)
+{
+ while (node) {
+ node = (node - 1) / 4;
+
+ int first_child = node * 4 + 1;
+
+ int largest_available = 0;
+ int largest_used = 0;
+
+ bool all_empty = true;
+
+ for (int i = 0; i < 4; ++i) {
+ largest_available = qMax(largest_available, occupied_quadtree[channel][first_child + i].largest_available_block);
+ largest_used = qMax(largest_used, occupied_quadtree[channel][first_child + i].largest_used_block);
+
+ if (occupied_quadtree[channel][first_child + i].largest_available_block < current_block_size)
+ all_empty = false;
+ }
+
+ current_block_size *= 2;
+
+ if (all_empty) {
+ occupied_quadtree[channel][node].largest_available_block = current_block_size;
+ occupied_quadtree[channel][node].largest_used_block = 0;
+ } else {
+ occupied_quadtree[channel][node].largest_available_block = largest_available;
+ occupied_quadtree[channel][node].largest_used_block = largest_used;
+ }
+ }
+}
+
+void QGLMaskTextureCache::quadtreeInsert(int channel, quint64 key, const QRect &rect, int node)
+{
+ int current_block_size = quadtreeBlocksize(node);
+ QPoint location = quadtreeLocation(node);
+ QRect relative = rect.translated(-location);
+
+ if (relative.left() >= current_block_size || relative.top() >= current_block_size
+ || relative.right() < 0 || relative.bottom() < 0)
+ return;
+
+ if (current_block_size == block_size // no more refining possible
+ || (relative.top() < block_size && relative.bottom() >= (current_block_size - block_size)
+ && relative.left() < block_size && relative.right() >= (current_block_size - block_size)))
+ {
+ if (key != 0) {
+ occupied_quadtree[channel][node].largest_available_block = 0;
+ occupied_quadtree[channel][node].largest_used_block = rect.width() * rect.height();
+ } else {
+ occupied_quadtree[channel][node].largest_available_block = current_block_size;
+ occupied_quadtree[channel][node].largest_used_block = 0;
+ }
+
+ occupied_quadtree[channel][node].key = key;
+
+ quadtreeUpdate(channel, node, current_block_size);
+ } else {
+ if (key && occupied_quadtree[channel][node].largest_available_block == current_block_size) {
+ // refining the quad tree, initialize child nodes
+ int half_block_size = current_block_size / 2;
+
+ int temp = node * 4 + 1;
+ for (int sibling = 0; sibling < 4; ++sibling) {
+ occupied_quadtree[channel][temp + sibling].largest_available_block = half_block_size;
+ occupied_quadtree[channel][temp + sibling].largest_used_block = 0;
+ occupied_quadtree[channel][temp + sibling].key = 0;
+ }
+ }
+
+ node = node * 4 + 1;
+
+ for (int sibling = 0; sibling < 4; ++sibling)
+ quadtreeInsert(channel, key, rect, node + sibling);
+ }
+}
+
+void QGLMaskTextureCache::quadtreeClear(int channel, const QRect &rect, int node)
+{
+ const quint64 &key = occupied_quadtree[channel][node].key;
+
+ int current_block_size = quadtreeBlocksize(node);
+ QPoint location = quadtreeLocation(node);
+
+ QRect relative = rect.translated(-location);
+
+ if (relative.left() >= current_block_size || relative.top() >= current_block_size
+ || relative.right() < 0 || relative.bottom() < 0)
+ return;
+
+ if (key != 0) {
+ QGLTextureCacheHash::iterator it = cache.find(key);
+
+ Q_ASSERT(it != cache.end());
+
+ while (it != cache.end() && it.key() == key) {
+ const CacheInfo &cache_info = it.value();
+
+ if (cache_info.loc.channel == channel
+ && cache_info.loc.rect.left() <= location.x()
+ && cache_info.loc.rect.top() <= location.y()
+ && cache_info.loc.rect.right() >= location.x()
+ && cache_info.loc.rect.bottom() >= location.y())
+ {
+ quadtreeInsert(channel, 0, cache_info.loc.rect);
+ engine->cacheItemErased(channel, cache_info.loc.rect);
+ cache.erase(it);
+ goto found;
+ } else {
+ ++it;
+ }
+ }
+
+ // if we don't find the key there's an error in the quadtree
+ Q_ASSERT(false);
+found:
+ Q_ASSERT(occupied_quadtree[channel][node].key == 0);
+ } else if (occupied_quadtree[channel][node].largest_available_block < current_block_size) {
+ Q_ASSERT(current_block_size >= block_size);
+
+ node = node * 4 + 1;
+
+ for (int sibling = 0; sibling < 4; ++sibling)
+ quadtreeClear(channel, rect, node + sibling);
+ }
+}
+
+bool QGLMaskTextureCache::quadtreeFindAvailableLocation(const QSize &size, QRect *rect, int *channel)
+{
+ int needed_block_size = qMax(1, qMax(size.width(), size.height()));
+
+ for (int i = 0; i < 4; ++i) {
+ int current_block_size = offscreenSize.width();
+
+ if (occupied_quadtree[i][0].largest_available_block >= needed_block_size) {
+ int node = 0;
+
+ while (current_block_size != occupied_quadtree[i][node].largest_available_block) {
+ Q_ASSERT(current_block_size > block_size);
+ Q_ASSERT(current_block_size > occupied_quadtree[i][node].largest_available_block);
+
+ node = node * 4 + 1;
+ current_block_size /= 2;
+
+ int sibling = 0;
+
+ while (occupied_quadtree[i][node + sibling].largest_available_block < needed_block_size)
+ ++sibling;
+
+ Q_ASSERT(sibling < 4);
+ node += sibling;
+ }
+
+ *channel = i;
+ *rect = QRect(quadtreeLocation(node), size);
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void QGLMaskTextureCache::quadtreeFindExistingLocation(const QSize &size, QRect *rect, int *channel)
+{
+ // try to pick small masks to throw out, as large masks are more expensive to recompute
+ *channel = qrand() % 4;
+ for (int i = 0; i < 4; ++i)
+ if (occupied_quadtree[i][0].largest_used_block < occupied_quadtree[*channel][0].largest_used_block)
+ *channel = i;
+
+ int needed_block_size = qt_next_power_of_two(qMax(1, qMax(size.width(), size.height())));
+
+ int node = 0;
+ int current_block_size = offscreenSize.width();
+
+ while (current_block_size > block_size
+ && current_block_size >= needed_block_size * 2
+ && occupied_quadtree[*channel][node].key == 0)
+ {
+ node = node * 4 + 1;
+
+ int sibling = 0;
+
+ for (int i = 1; i < 4; ++i) {
+ if (occupied_quadtree[*channel][node + i].largest_used_block
+ <= occupied_quadtree[*channel][node + sibling].largest_used_block)
+ {
+ sibling = i;
+ }
+ }
+
+ node += sibling;
+ current_block_size /= 2;
+ }
+
+ *rect = QRect(quadtreeLocation(node), size);
+}
+
+void QGLMaskTextureCache::quadtreeAllocate(quint64 key, const QSize &size, QRect *rect, int *channel)
+{
+#ifndef DISABLE_MASK_CACHE
+ if (!quadtreeFindAvailableLocation(size, rect, channel)) {
+ quadtreeFindExistingLocation(size, rect, channel);
+ quadtreeClear(*channel, *rect);
+ }
+
+ quadtreeInsert(*channel, key, *rect);
+#else
+ *channel = 0;
+ *rect = QRect(QPoint(), size);
+#endif
+}
+
+class QGLTrapezoidMaskGenerator : public QGLMaskGenerator
+{
+public:
+ QGLTrapezoidMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram, qreal strokeWidth = -1.0);
+
+ QRect screenRect();
+ void drawMask(const QRect &rect);
+
+private:
+ QRect screen_rect;
+ bool has_screen_rect;
+
+ QGLOffscreen *offscreen;
+
+ GLuint maskFragmentProgram;
+
+ virtual QVector<QGLTrapezoid> generateTrapezoids() = 0;
+ virtual QRect computeScreenRect() = 0;
+};
+
+class QGLPathMaskGenerator : public QGLTrapezoidMaskGenerator
+{
+public:
+ QGLPathMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
+
+private:
+ QVector<QGLTrapezoid> generateTrapezoids();
+ QRect computeScreenRect();
+
+ QPolygonF poly;
+};
+
+class QGLLineMaskGenerator : public QGLTrapezoidMaskGenerator
+{
+public:
+ QGLLineMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal width, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
+
+private:
+ QVector<QGLTrapezoid> generateTrapezoids();
+ QRect computeScreenRect();
+
+ QPainterPath transformedPath;
+};
+
+class QGLRectMaskGenerator : public QGLTrapezoidMaskGenerator
+{
+public:
+ QGLRectMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram);
+
+private:
+ QVector<QGLTrapezoid> generateTrapezoids();
+ QRect computeScreenRect();
+
+ QPainterPath transformedPath;
+};
+
+class QGLEllipseMaskGenerator : public QGLMaskGenerator
+{
+public:
+ QGLEllipseMaskGenerator(const QRectF &rect, const QTransform &matrix, QGLOffscreen &offscreen, GLuint maskFragmentProgram, int *maskVariableLocations);
+
+ QRect screenRect();
+ void drawMask(const QRect &rect);
+
+private:
+ QRect screen_rect;
+
+ QRectF ellipseRect;
+
+ QGLOffscreen *offscreen;
+
+ GLuint maskFragmentProgram;
+
+ int *maskVariableLocations;
+
+ float vertexArray[4 * 2];
+};
+
+QGLTrapezoidMaskGenerator::QGLTrapezoidMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program, qreal stroke_width)
+ : QGLMaskGenerator(path, matrix, stroke_width)
+ , has_screen_rect(false)
+ , offscreen(&offs)
+ , maskFragmentProgram(program)
+{
+}
+
+extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array);
+extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array);
+
+void QGLTrapezoidMaskGenerator::drawMask(const QRect &rect)
+{
+#ifdef QT_OPENGL_ES
+ Q_UNUSED(rect);
+#else
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+
+ QGLContext *ctx = offscreen->context();
+ offscreen->bind();
+
+ glDisable(GL_TEXTURE_GEN_S);
+ glDisable(GL_TEXTURE_1D);
+
+ GLfloat vertexArray[4 * 2];
+ qt_add_rect_to_array(rect, vertexArray);
+
+ bool needs_scissor = rect != screen_rect;
+
+ if (needs_scissor) {
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(rect.left(), offscreen->offscreenSize().height() - rect.bottom() - 1, rect.width(), rect.height());
+ }
+
+ QVector<QGLTrapezoid> trapezoids = generateTrapezoids();
+
+ // clear mask
+ glBlendFunc(GL_ZERO, GL_ZERO); // clear
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ glBlendFunc(GL_ONE, GL_ONE); // add mask
+ glEnable(GL_FRAGMENT_PROGRAM_ARB);
+ glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, maskFragmentProgram);
+
+ QPoint delta = rect.topLeft() - screen_rect.topLeft();
+ glBegin(GL_QUADS);
+ for (int i = 0; i < trapezoids.size(); ++i)
+ drawTrapezoid(trapezoids[i].translated(delta), offscreen->offscreenSize().height(), ctx);
+ glEnd();
+
+ if (needs_scissor)
+ glDisable(GL_SCISSOR_TEST);
+
+ glDisable(GL_FRAGMENT_PROGRAM_ARB);
+
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+#endif
+}
+
+QRect QGLTrapezoidMaskGenerator::screenRect()
+{
+ if (!has_screen_rect) {
+ screen_rect = computeScreenRect();
+ has_screen_rect = true;
+ }
+
+ screen_rect = screen_rect.intersected(QRect(QPoint(), offscreen->drawableSize()));
+
+ return screen_rect;
+}
+
+QGLPathMaskGenerator::QGLPathMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program)
+ : QGLTrapezoidMaskGenerator(path, matrix, offs, program)
+{
+}
+
+QRect QGLPathMaskGenerator::computeScreenRect()
+{
+ poly = path().toFillPolygon(matrix());
+ return poly.boundingRect().toAlignedRect();
+}
+
+QVector<QGLTrapezoid> QGLPathMaskGenerator::generateTrapezoids()
+{
+ QOpenGLImmediateModeTessellator tessellator;
+ tessellator.tessellate(poly.data(), poly.count(), path().fillRule() == Qt::WindingFill);
+ return tessellator.trapezoids;
+}
+
+QGLRectMaskGenerator::QGLRectMaskGenerator(const QPainterPath &path, const QTransform &matrix, QGLOffscreen &offs, GLuint program)
+ : QGLTrapezoidMaskGenerator(path, matrix, offs, program)
+{
+}
+
+QGLLineMaskGenerator::QGLLineMaskGenerator(const QPainterPath &path, const QTransform &matrix, qreal width, QGLOffscreen &offs, GLuint program)
+ : QGLTrapezoidMaskGenerator(path, matrix, offs, program, width)
+{
+}
+
+QRect QGLRectMaskGenerator::computeScreenRect()
+{
+ transformedPath = matrix().map(path());
+
+ return transformedPath.controlPointRect().adjusted(-1, -1, 1, 1).toAlignedRect();
+}
+
+QRect QGLLineMaskGenerator::computeScreenRect()
+{
+ transformedPath = matrix().map(path());
+
+ return transformedPath.controlPointRect().adjusted(-1, -1, 1, 1).toAlignedRect();
+}
+
+QVector<QGLTrapezoid> QGLLineMaskGenerator::generateTrapezoids()
+{
+ QOpenGLImmediateModeTessellator tessellator;
+ QPointF last;
+ for (int i = 0; i < transformedPath.elementCount(); ++i) {
+ QPainterPath::Element element = transformedPath.elementAt(i);
+
+ Q_ASSERT(!element.isCurveTo());
+
+ if (element.isLineTo())
+ tessellator.tessellateRect(last, element, strokeWidth());
+
+ last = element;
+ }
+
+ return tessellator.trapezoids;
+}
+
+QVector<QGLTrapezoid> QGLRectMaskGenerator::generateTrapezoids()
+{
+ Q_ASSERT(transformedPath.elementCount() == 5);
+
+ QOpenGLImmediateModeTessellator tessellator;
+ if (matrix().type() <= QTransform::TxScale) {
+ QPointF a = transformedPath.elementAt(0);
+ QPointF b = transformedPath.elementAt(1);
+ QPointF c = transformedPath.elementAt(2);
+ QPointF d = transformedPath.elementAt(3);
+
+ QPointF first = (a + d) * 0.5;
+ QPointF last = (b + c) * 0.5;
+
+ QPointF delta = a - d;
+
+ // manhattan distance (no rotation)
+ qreal width = qAbs(delta.x()) + qAbs(delta.y());
+
+ Q_ASSERT(qFuzzyIsNull(delta.x()) || qFuzzyIsNull(delta.y()));
+
+ tessellator.tessellateRect(first, last, width);
+ } else {
+ QPointF points[5];
+
+ for (int i = 0; i < 5; ++i)
+ points[i] = transformedPath.elementAt(i);
+
+ tessellator.tessellateConvex(points, 5);
+ }
+ return tessellator.trapezoids;
+}
+
+static QPainterPath ellipseRectToPath(const QRectF &rect)
+{
+ QPainterPath path;
+ path.addEllipse(rect);
+ return path;
+}
+
+QGLEllipseMaskGenerator::QGLEllipseMaskGenerator(const QRectF &rect, const QTransform &matrix, QGLOffscreen &offs, GLuint program, int *locations)
+ : QGLMaskGenerator(ellipseRectToPath(rect), matrix),
+ ellipseRect(rect),
+ offscreen(&offs),
+ maskFragmentProgram(program),
+ maskVariableLocations(locations)
+{
+}
+
+QRect QGLEllipseMaskGenerator::screenRect()
+{
+ QPointF center = ellipseRect.center();
+
+ QPointF points[] = {
+ QPointF(ellipseRect.left(), center.y()),
+ QPointF(ellipseRect.right(), center.y()),
+ QPointF(center.x(), ellipseRect.top()),
+ QPointF(center.x(), ellipseRect.bottom())
+ };
+
+ qreal min_screen_delta_len = QREAL_MAX;
+
+ for (int i = 0; i < 4; ++i) {
+ QPointF delta = points[i] - center;
+
+ // normalize
+ delta /= qSqrt(delta.x() * delta.x() + delta.y() * delta.y());
+
+ QPointF screen_delta(matrix().m11() * delta.x() + matrix().m21() * delta.y(),
+ matrix().m12() * delta.x() + matrix().m22() * delta.y());
+
+ min_screen_delta_len = qMin(min_screen_delta_len,
+ qreal(qSqrt(screen_delta.x() * screen_delta.x() + screen_delta.y() * screen_delta.y())));
+ }
+
+ const qreal padding = 2.0f;
+
+ qreal grow = padding / min_screen_delta_len;
+
+ QRectF boundingRect = ellipseRect.adjusted(-grow, -grow, grow, grow);
+
+ boundingRect = matrix().mapRect(boundingRect);
+
+ QPointF p(0.5, 0.5);
+
+ screen_rect = QRect((boundingRect.topLeft() - p).toPoint(),
+ (boundingRect.bottomRight() + p).toPoint());
+
+ return screen_rect;
+}
+
+void QGLEllipseMaskGenerator::drawMask(const QRect &rect)
+{
+#ifdef QT_OPENGL_ES
+ Q_UNUSED(rect);
+#else
+ QGLContext *ctx = offscreen->context();
+ offscreen->bind();
+
+ glDisable(GL_TEXTURE_GEN_S);
+ glDisable(GL_TEXTURE_1D);
+
+ // fragment program needs the inverse radii of the ellipse
+ glTexCoord2f(1.0f / (ellipseRect.width() * 0.5f),
+ 1.0f / (ellipseRect.height() * 0.5f));
+
+ QTransform translate(1, 0, 0, 1, -ellipseRect.center().x(), -ellipseRect.center().y());
+ QTransform gl_to_qt(1, 0, 0, -1, 0, offscreen->drawableSize().height());
+ QTransform inv_matrix = gl_to_qt * matrix().inverted() * translate;
+
+ float m[3][4] = { { inv_matrix.m11(), inv_matrix.m12(), inv_matrix.m13() },
+ { inv_matrix.m21(), inv_matrix.m22(), inv_matrix.m23() },
+ { inv_matrix.m31(), inv_matrix.m32(), inv_matrix.m33() } };
+
+ QPoint offs(screen_rect.left() - rect.left(), (offscreen->drawableSize().height() - screen_rect.top())
+ - (offscreen->offscreenSize().height() - rect.top()));
+
+ // last component needs to be 1.0f to avoid Nvidia bug on linux
+ float ellipse_offset[4] = { offs.x(), offs.y(), 0.0f, 1.0f };
+
+ GLfloat vertexArray[4 * 2];
+ qt_add_rect_to_array(rect, vertexArray);
+
+ glBlendFunc(GL_ONE, GL_ZERO); // set mask
+ glEnable(GL_FRAGMENT_PROGRAM_ARB);
+ glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, maskFragmentProgram);
+
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M0], m[0]);
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M1], m[1]);
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_INV_MATRIX_M2], m[2]);
+
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, maskVariableLocations[VAR_ELLIPSE_OFFSET], ellipse_offset);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisable(GL_FRAGMENT_PROGRAM_ARB);
+#endif
+}
+
+void QOpenGLPaintEnginePrivate::drawOffscreenPath(const QPainterPath &path)
+{
+#ifdef Q_WS_QWS
+ Q_UNUSED(path);
+#else
+ DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::drawOffscreenPath()");
+
+ disableClipping();
+
+ GLuint program = qt_gl_program_cache()->getProgram(device->context(),
+ FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
+ QGLPathMaskGenerator maskGenerator(path, matrix, offscreen, program);
+ addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
+
+ enableClipping();
+#endif
+}
+
+void QOpenGLPaintEnginePrivate::drawFastRect(const QRectF &r)
+{
+ Q_Q(QOpenGLPaintEngine);
+ DEBUG_ONCE_STR("QOpenGLPaintEngine::drawRects(): drawing fast rect");
+
+ q_vertexType vertexArray[10];
+ qt_add_rect_to_array(r, vertexArray);
+
+ if (has_pen)
+ QOpenGLCoordinateOffset::enableOffset(this);
+
+ if (has_brush) {
+ flushDrawQueue();
+
+ bool temp = high_quality_antialiasing;
+ high_quality_antialiasing = false;
+
+ q->updateCompositionMode(composition_mode);
+
+ setGradientOps(cbrush, r);
+
+ bool fast_style = current_style == Qt::LinearGradientPattern
+ || current_style == Qt::SolidPattern;
+
+ if (fast_style && has_fast_composition_mode) {
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ } else {
+ composite(r);
+ }
+
+ high_quality_antialiasing = temp;
+
+ q->updateCompositionMode(composition_mode);
+ }
+
+ if (has_pen) {
+ if (has_fast_pen && !high_quality_antialiasing) {
+ setGradientOps(cpen.brush(), r);
+
+ vertexArray[8] = vertexArray[0];
+ vertexArray[9] = vertexArray[1];
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glDrawArrays(GL_LINE_STRIP, 0, 5);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ } else {
+ QPainterPath path;
+ path.setFillRule(Qt::WindingFill);
+
+ qreal left = r.left();
+ qreal right = r.right();
+ qreal top = r.top();
+ qreal bottom = r.bottom();
+
+ path.moveTo(left, top);
+ path.lineTo(right, top);
+ path.lineTo(right, bottom);
+ path.lineTo(left, bottom);
+ path.lineTo(left, top);
+
+ strokePath(path, false);
+ }
+
+ QOpenGLCoordinateOffset::disableOffset(this);
+ }
+}
+
+bool QOpenGLPaintEnginePrivate::isFastRect(const QRectF &rect)
+{
+ if (matrix.type() < QTransform::TxRotate) {
+ QRectF r = matrix.mapRect(rect);
+ return r.topLeft().toPoint() == r.topLeft()
+ && r.bottomRight().toPoint() == r.bottomRight();
+ }
+
+ return false;
+}
+
+void QOpenGLPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+ struct RectF {
+ qreal x;
+ qreal y;
+ qreal w;
+ qreal h;
+ };
+ Q_ASSERT(sizeof(RectF) == sizeof(QRectF));
+ RectF fr[256];
+ while (rectCount) {
+ int i = 0;
+ while (i < rectCount && i < 256) {
+ fr[i].x = rects[i].x();
+ fr[i].y = rects[i].y();
+ fr[i].w = rects[i].width();
+ fr[i].h = rects[i].height();
+ ++i;
+ }
+ drawRects((QRectF *)(void *)fr, i);
+ rects += i;
+ rectCount -= i;
+ }
+}
+
+void QOpenGLPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawRects(rects, rectCount);
+ return;
+ }
+
+ for (int i=0; i<rectCount; ++i) {
+ const QRectF &r = rects[i];
+
+ // optimization for rects which can be drawn aliased
+ if (!d->high_quality_antialiasing || d->isFastRect(r)) {
+ d->drawFastRect(r);
+ } else {
+ QPainterPath path;
+ path.addRect(r);
+
+ if (d->has_brush) {
+ d->disableClipping();
+ GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
+ FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
+
+ if (d->matrix.type() >= QTransform::TxProject) {
+ QGLPathMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
+ d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+ } else {
+ QGLRectMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
+ d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+ }
+
+ d->enableClipping();
+ }
+
+ if (d->has_pen) {
+ if (d->has_fast_pen)
+ d->strokeLines(path);
+ else
+ d->strokePath(path, false);
+ }
+ }
+ }
+}
+
+static void addQuadAsTriangle(q_vertexType *quad, q_vertexType *triangle)
+{
+ triangle[0] = quad[0];
+ triangle[1] = quad[1];
+
+ triangle[2] = quad[2];
+ triangle[3] = quad[3];
+
+ triangle[4] = quad[4];
+ triangle[5] = quad[5];
+
+ triangle[6] = quad[4];
+ triangle[7] = quad[5];
+
+ triangle[8] = quad[6];
+ triangle[9] = quad[7];
+
+ triangle[10] = quad[0];
+ triangle[11] = quad[1];
+}
+
+void QOpenGLPaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+ Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+ QT_PointF fp[256];
+ while (pointCount) {
+ int i = 0;
+ while (i < pointCount && i < 256) {
+ fp[i].x = points[i].x();
+ fp[i].y = points[i].y();
+ ++i;
+ }
+ drawPoints((QPointF *)(void *)fp, i);
+ points += i;
+ pointCount -= i;
+ }
+}
+
+void QOpenGLPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawPoints(points, pointCount);
+ return;
+ }
+
+ d->setGradientOps(d->cpen.brush(), QRectF());
+
+ if (!d->cpen.isCosmetic() || d->high_quality_antialiasing) {
+ Qt::PenCapStyle capStyle = d->cpen.capStyle();
+ if (capStyle == Qt::FlatCap)
+ d->cpen.setCapStyle(Qt::SquareCap);
+ QPaintEngine::drawPoints(points, pointCount);
+ d->cpen.setCapStyle(capStyle);
+ return;
+ }
+
+ d->flushDrawQueue();
+
+ if (d->has_fast_pen) {
+ QVarLengthArray<q_vertexType> vertexArray(6 * pointCount);
+
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+
+ int j = 0;
+ for (int i = 0; i < pointCount; ++i) {
+ QPointF mapped = d->matrix.map(points[i]);
+
+ qreal xf = qRound(mapped.x());
+ qreal yf = qRound(mapped.y());
+
+ q_vertexType x = f2vt(xf);
+ q_vertexType y = f2vt(yf);
+
+ vertexArray[j++] = x;
+ vertexArray[j++] = y - f2vt(0.5);
+
+ vertexArray[j++] = x + f2vt(1.5);
+ vertexArray[j++] = y + f2vt(1.0);
+
+ vertexArray[j++] = x;
+ vertexArray[j++] = y + f2vt(1.0);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+ glDrawArrays(GL_TRIANGLES, 0, pointCount*3);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ glPopMatrix();
+ return;
+ }
+
+ const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
+
+ if (sizeof(qreal) == sizeof(double)) {
+ Q_ASSERT(sizeof(QPointF) == 16);
+ glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
+ }
+ else {
+ Q_ASSERT(sizeof(QPointF) == 8);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glDrawArrays(GL_POINTS, 0, pointCount);
+ glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void QOpenGLPaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+ struct PointF {
+ qreal x;
+ qreal y;
+ };
+ struct LineF {
+ PointF p1;
+ PointF p2;
+ };
+ Q_ASSERT(sizeof(PointF) == sizeof(QPointF));
+ Q_ASSERT(sizeof(LineF) == sizeof(QLineF));
+ LineF fl[256];
+ while (lineCount) {
+ int i = 0;
+ while (i < lineCount && i < 256) {
+ fl[i].p1.x = lines[i].x1();
+ fl[i].p1.y = lines[i].y1();
+ fl[i].p2.x = lines[i].x2();
+ fl[i].p2.y = lines[i].y2();
+ ++i;
+ }
+ drawLines((QLineF *)(void *)fl, i);
+ lines += i;
+ lineCount -= i;
+ }
+}
+
+void QOpenGLPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawLines(lines, lineCount);
+ return;
+ }
+
+ if (d->has_pen) {
+ QOpenGLCoordinateOffset offset(d);
+ if (d->has_fast_pen && !d->high_quality_antialiasing) {
+ //### gradient resolving on lines isn't correct
+ d->setGradientOps(d->cpen.brush(), QRectF());
+
+ bool useRects = false;
+ // scale or 90 degree rotation?
+ if (d->matrix.type() <= QTransform::TxTranslate
+ || (!d->cpen.isCosmetic()
+ && (d->matrix.type() <= QTransform::TxScale
+ || (d->matrix.type() == QTransform::TxRotate
+ && d->matrix.m11() == 0 && d->matrix.m22() == 0)))) {
+ useRects = true;
+ for (int i = 0; i < lineCount; ++i) {
+ if (lines[i].p1().x() != lines[i].p2().x()
+ && lines[i].p1().y() != lines[i].p2().y()) {
+ useRects = false;
+ break;
+ }
+ }
+ }
+
+ q_vertexType endCap = f2vt(d->cpen.capStyle() == Qt::FlatCap ? 0 : 0.5);
+ if (useRects) {
+ QVarLengthArray<q_vertexType> vertexArray(12 * lineCount);
+
+ q_vertexType quad[8];
+ for (int i = 0; i < lineCount; ++i) {
+ q_vertexType x1 = f2vt(lines[i].x1());
+ q_vertexType x2 = f2vt(lines[i].x2());
+ q_vertexType y1 = f2vt(lines[i].y1());
+ q_vertexType y2 = f2vt(lines[i].y2());
+
+ if (x1 == x2) {
+ if (y1 > y2)
+ qSwap(y1, y2);
+
+ quad[0] = x1 - f2vt(0.5);
+ quad[1] = y1 - endCap;
+
+ quad[2] = x1 + f2vt(0.5);
+ quad[3] = y1 - endCap;
+
+ quad[4] = x1 + f2vt(0.5);
+ quad[5] = y2 + endCap;
+
+ quad[6] = x1 - f2vt(0.5);
+ quad[7] = y2 + endCap;
+ } else {
+ if (x1 > x2)
+ qSwap(x1, x2);
+
+ quad[0] = x1 - endCap;
+ quad[1] = y1 + f2vt(0.5);
+
+ quad[2] = x1 - endCap;
+ quad[3] = y1 - f2vt(0.5);
+
+ quad[4] = x2 + endCap;
+ quad[5] = y1 - f2vt(0.5);
+
+ quad[6] = x2 + endCap;
+ quad[7] = y1 + f2vt(0.5);
+ }
+
+ addQuadAsTriangle(quad, &vertexArray[12*i]);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+ glDrawArrays(GL_TRIANGLES, 0, lineCount*6);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ } else {
+ QVarLengthArray<q_vertexType> vertexArray(4 * lineCount);
+ for (int i = 0; i < lineCount; ++i) {
+ const QPointF a = lines[i].p1();
+ vertexArray[4*i] = f2vt(lines[i].x1());
+ vertexArray[4*i+1] = f2vt(lines[i].y1());
+ vertexArray[4*i+2] = f2vt(lines[i].x2());
+ vertexArray[4*i+3] = f2vt(lines[i].y2());
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+ glDrawArrays(GL_LINES, 0, lineCount*2);
+
+ glVertexPointer(2, q_vertexTypeEnum, 4*sizeof(q_vertexType), vertexArray.constData() + 2);
+ glDrawArrays(GL_POINTS, 0, lineCount);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ }
+ } else {
+ QPainterPath path;
+ path.setFillRule(Qt::WindingFill);
+ for (int i=0; i<lineCount; ++i) {
+ const QLineF &l = lines[i];
+
+ if (l.p1() == l.p2()) {
+ if (d->cpen.capStyle() != Qt::FlatCap) {
+ QPointF p = l.p1();
+ drawPoints(&p, 1);
+ }
+ continue;
+ }
+
+ path.moveTo(l.x1(), l.y1());
+ path.lineTo(l.x2(), l.y2());
+ }
+
+ if (d->has_fast_pen && d->high_quality_antialiasing)
+ d->strokeLines(path);
+ else
+ d->strokePath(path, false);
+ }
+ }
+}
+
+void QOpenGLPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+ QVarLengthArray<QT_PointF> p(pointCount);
+ for (int i=0; i<pointCount; ++i) {
+ p[i].x = points[i].x();
+ p[i].y = points[i].y();
+ }
+ drawPolygon((QPointF *)p.data(), pointCount, mode);
+}
+
+void QOpenGLPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+ Q_D(QOpenGLPaintEngine);
+ if(pointCount < 2)
+ return;
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawPolygon(points, pointCount, mode);
+ return;
+ }
+
+ QRectF bounds;
+ if ((mode == ConvexMode && !d->high_quality_antialiasing && state()->brushNeedsResolving()) ||
+ ((d->has_fast_pen && !d->high_quality_antialiasing) && state()->penNeedsResolving())) {
+ qreal minx = points[0].x(), miny = points[0].y(),
+ maxx = points[0].x(), maxy = points[0].y();
+ for (int i = 1; i < pointCount; ++i) {
+ const QPointF &pt = points[i];
+ if (minx > pt.x())
+ minx = pt.x();
+ if (miny > pt.y())
+ miny = pt.y();
+ if (maxx < pt.x())
+ maxx = pt.x();
+ if (maxy < pt.y())
+ maxy = pt.y();
+ }
+ bounds = QRectF(minx, maxx, maxx-minx, maxy-miny);
+ }
+
+ QOpenGLCoordinateOffset offset(d);
+
+ if (d->has_brush && mode != PolylineMode) {
+ if (mode == ConvexMode && !d->high_quality_antialiasing) {
+ //### resolving on polygon from points isn't correct
+ d->setGradientOps(d->cbrush, bounds);
+
+ const qreal *vertexArray = reinterpret_cast<const qreal*>(&points[0]);
+
+ if (sizeof(qreal) == sizeof(double)) {
+ Q_ASSERT(sizeof(QPointF) == 16);
+ glVertexPointer(2, GL_DOUBLE, 0, vertexArray);
+ }
+ else {
+ Q_ASSERT(sizeof(QPointF) == 8);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, pointCount);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ } else {
+ QPainterPath path;
+ path.setFillRule(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
+ path.moveTo(points[0]);
+ for (int i=1; i<pointCount; ++i)
+ path.lineTo(points[i]);
+ d->fillPath(path);
+ }
+ }
+
+ if (d->has_pen) {
+ if (d->has_fast_pen && !d->high_quality_antialiasing) {
+ d->setGradientOps(d->cpen.brush(), bounds);
+ QVarLengthArray<q_vertexType> vertexArray(pointCount*2 + 2);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+ int i;
+ for (i=0; i<pointCount; ++i) {
+ vertexArray[i*2] = f2vt(points[i].x());
+ vertexArray[i*2+1] = f2vt(points[i].y());
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ if (mode != PolylineMode) {
+ vertexArray[i*2] = vertexArray[0];
+ vertexArray[i*2+1] = vertexArray[1];
+ glDrawArrays(GL_LINE_STRIP, 0, pointCount+1);
+ } else {
+ glDrawArrays(GL_LINE_STRIP, 0, pointCount);
+ glDrawArrays(GL_POINTS, pointCount-1, 1);
+ }
+ glDisableClientState(GL_VERTEX_ARRAY);
+ } else {
+ QPainterPath path(points[0]);
+ for (int i = 1; i < pointCount; ++i)
+ path.lineTo(points[i]);
+ if (mode != PolylineMode)
+ path.lineTo(points[0]);
+
+ if (d->has_fast_pen)
+ d->strokeLines(path);
+ else
+ d->strokePath(path, true);
+ }
+ }
+}
+
+void QOpenGLPaintEnginePrivate::strokeLines(const QPainterPath &path)
+{
+ DEBUG_ONCE_STR("QOpenGLPaintEnginePrivate::strokeLines()");
+
+ qreal penWidth = cpen.widthF();
+
+ GLuint program = qt_gl_program_cache()->getProgram(device->context(),
+ FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
+ QGLLineMaskGenerator maskGenerator(path, matrix, penWidth == 0 ? 1.0 : penWidth,
+ offscreen, program);
+
+ disableClipping();
+
+ QBrush temp = cbrush;
+ QPointF origin = brush_origin;
+
+ cbrush = cpen.brush();
+ brush_origin = QPointF();
+
+ addItem(qt_mask_texture_cache()->getMask(maskGenerator, this));
+
+ cbrush = temp;
+ brush_origin = origin;
+
+ enableClipping();
+}
+
+extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+
+void QOpenGLPaintEnginePrivate::strokePath(const QPainterPath &path, bool use_cache)
+{
+ QBrush old_brush = cbrush;
+ cbrush = cpen.brush();
+
+ qreal txscale = 1;
+ if (cpen.isCosmetic() || (qt_scaleForTransform(matrix, &txscale) && txscale != 1)) {
+ QTransform temp = matrix;
+ matrix = QTransform();
+ glPushMatrix();
+
+ if (has_antialiasing) {
+ glLoadIdentity();
+ } else {
+ float offs_matrix[] =
+ { 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0.5, 0.5, 0, 1 };
+ glLoadMatrixf(offs_matrix);
+ }
+
+ QPen pen = cpen;
+ if (txscale != 1)
+ pen.setWidthF(pen.widthF() * txscale);
+ if (use_cache)
+ fillPath(qt_opengl_stroke_cache()->getStrokedPath(temp.map(path), pen));
+ else
+ fillPath(strokeForPath(temp.map(path), pen));
+
+ glPopMatrix();
+ matrix = temp;
+ } else if (use_cache) {
+ fillPath(qt_opengl_stroke_cache()->getStrokedPath(path, cpen));
+ } else {
+ fillPath(strokeForPath(path, cpen));
+ }
+
+ cbrush = old_brush;
+}
+
+void QOpenGLPaintEnginePrivate::strokePathFastPen(const QPainterPath &path, bool needsResolving)
+{
+#ifndef QT_OPENGL_ES
+ QRectF bounds;
+ if (needsResolving)
+ bounds = path.controlPointRect();
+ setGradientOps(cpen.brush(), bounds);
+
+ QBezier beziers[32];
+ for (int i=0; i<path.elementCount(); ++i) {
+ const QPainterPath::Element &e = path.elementAt(i);
+ switch (e.type) {
+ case QPainterPath::MoveToElement:
+ if (i != 0)
+ glEnd(); // GL_LINE_STRIP
+ glBegin(GL_LINE_STRIP);
+ glVertex2d(e.x, e.y);
+
+ break;
+ case QPainterPath::LineToElement:
+ glVertex2d(e.x, e.y);
+ break;
+
+ case QPainterPath::CurveToElement:
+ {
+ QPointF sp = path.elementAt(i-1);
+ QPointF cp2 = path.elementAt(i+1);
+ QPointF ep = path.elementAt(i+2);
+ i+=2;
+
+ qreal inverseScaleHalf = inverseScale / 2;
+ beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
+ QBezier *b = beziers;
+ while (b >= beziers) {
+ // check if we can pop the top bezier curve from the stack
+ qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
+ qreal d;
+ if (l > inverseScale) {
+ d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
+ - (b->y4 - b->y1)*(b->x1 - b->x2) )
+ + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
+ - (b->y4 - b->y1)*(b->x1 - b->x3) );
+ d /= l;
+ } else {
+ d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
+ qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
+ }
+ if (d < inverseScaleHalf || b == beziers + 31) {
+ // good enough, we pop it off and add the endpoint
+ glVertex2d(b->x4, b->y4);
+ --b;
+ } else {
+ // split, second half of the polygon goes lower into the stack
+ b->split(b+1, b);
+ ++b;
+ }
+ }
+ } // case CurveToElement
+ default:
+ break;
+ } // end of switch
+ }
+ glEnd(); // GL_LINE_STRIP
+#else
+ // have to use vertex arrays on embedded
+ QRectF bounds;
+ if (needsResolving)
+ bounds = path.controlPointRect();
+ setGradientOps(cpen.brush(), bounds);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ tess_points.reset();
+ QBezier beziers[32];
+ for (int i=0; i<path.elementCount(); ++i) {
+ const QPainterPath::Element &e = path.elementAt(i);
+ switch (e.type) {
+ case QPainterPath::MoveToElement:
+ if (i != 0) {
+ glVertexPointer(2, q_vertexTypeEnum, 0, tess_points.data());
+ glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
+ tess_points.reset();
+ }
+ tess_points.add(QPointF(e.x, e.y));
+
+ break;
+ case QPainterPath::LineToElement:
+ tess_points.add(QPointF(e.x, e.y));
+ break;
+
+ case QPainterPath::CurveToElement:
+ {
+ QPointF sp = path.elementAt(i-1);
+ QPointF cp2 = path.elementAt(i+1);
+ QPointF ep = path.elementAt(i+2);
+ i+=2;
+
+ qreal inverseScaleHalf = inverseScale / 2;
+ beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
+ QBezier *b = beziers;
+ while (b >= beziers) {
+ // check if we can pop the top bezier curve from the stack
+ qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
+ qreal d;
+ if (l > inverseScale) {
+ d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
+ - (b->y4 - b->y1)*(b->x1 - b->x2) )
+ + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
+ - (b->y4 - b->y1)*(b->x1 - b->x3) );
+ d /= l;
+ } else {
+ d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
+ qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
+ }
+ if (d < inverseScaleHalf || b == beziers + 31) {
+ // good enough, we pop it off and add the endpoint
+ tess_points.add(QPointF(b->x4, b->y4));
+ --b;
+ } else {
+ // split, second half of the polygon goes lower into the stack
+ b->split(b+1, b);
+ ++b;
+ }
+ }
+ } // case CurveToElement
+ default:
+ break;
+ } // end of switch
+ }
+ glVertexPointer(2, q_vertexTypeEnum, 0, tess_points.data());
+ glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
+ glDisableClientState(GL_VERTEX_ARRAY);
+#endif
+}
+
+static bool pathClosed(const QPainterPath &path)
+{
+ QPointF lastMoveTo = path.elementAt(0);
+ QPointF lastPoint = lastMoveTo;
+
+ for (int i = 1; i < path.elementCount(); ++i) {
+ const QPainterPath::Element &e = path.elementAt(i);
+ switch (e.type) {
+ case QPainterPath::MoveToElement:
+ if (lastMoveTo != lastPoint)
+ return false;
+ lastMoveTo = lastPoint = e;
+ break;
+ case QPainterPath::LineToElement:
+ lastPoint = e;
+ break;
+ case QPainterPath::CurveToElement:
+ lastPoint = path.elementAt(i + 2);
+ i+=2;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return lastMoveTo == lastPoint;
+}
+
+void QOpenGLPaintEngine::drawPath(const QPainterPath &path)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (path.isEmpty())
+ return;
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawPath(path);
+ return;
+ }
+
+ QOpenGLCoordinateOffset offset(d);
+
+ if (d->has_brush) {
+ bool path_closed = pathClosed(path);
+
+ bool has_thick_pen =
+ path_closed
+ && d->has_pen
+ && d->cpen.style() == Qt::SolidLine
+ && d->cpen.isSolid()
+ && d->cpen.color().alpha() == 255
+ && d->txop < QTransform::TxProject
+ && d->cpen.widthF() >= 2 / qSqrt(qMin(d->matrix.m11() * d->matrix.m11()
+ + d->matrix.m21() * d->matrix.m21(),
+ d->matrix.m12() * d->matrix.m12()
+ + d->matrix.m22() * d->matrix.m22()));
+
+ if (has_thick_pen) {
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::drawPath(): Using thick pen optimization, style:" << d->cbrush.style();
+
+ d->flushDrawQueue();
+
+ bool temp = d->high_quality_antialiasing;
+ d->high_quality_antialiasing = false;
+
+ updateCompositionMode(d->composition_mode);
+
+ d->fillPath(path);
+
+ d->high_quality_antialiasing = temp;
+ updateCompositionMode(d->composition_mode);
+ } else {
+ d->fillPath(path);
+ }
+ }
+
+ if (d->has_pen) {
+ if (d->has_fast_pen && !d->high_quality_antialiasing)
+ d->strokePathFastPen(path, state()->penNeedsResolving());
+ else
+ d->strokePath(path, true);
+ }
+}
+
+void QOpenGLPaintEnginePrivate::drawImageAsPath(const QRectF &r, const QImage &img, const QRectF &sr)
+{
+ QBrush old_brush = cbrush;
+ QPointF old_brush_origin = brush_origin;
+
+ qreal scaleX = r.width() / sr.width();
+ qreal scaleY = r.height() / sr.height();
+
+ QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
+ brush_matrix.scale(scaleX, scaleY);
+ brush_matrix.translate(-sr.left(), -sr.top());
+
+ cbrush = QBrush(img);
+ cbrush.setTransform(brush_matrix);
+ brush_origin = QPointF();
+
+ QPainterPath p;
+ p.addRect(r);
+ fillPath(p);
+
+ cbrush = old_brush;
+ brush_origin = old_brush_origin;
+}
+
+void QOpenGLPaintEnginePrivate::drawTiledImageAsPath(const QRectF &r, const QImage &img, qreal sx, qreal sy,
+ const QPointF &offset)
+{
+ QBrush old_brush = cbrush;
+ QPointF old_brush_origin = brush_origin;
+
+ QTransform brush_matrix = QTransform::fromTranslate(r.left(), r.top());
+ brush_matrix.scale(sx, sy);
+ brush_matrix.translate(-offset.x(), -offset.y());
+
+ cbrush = QBrush(img);
+ cbrush.setTransform(brush_matrix);
+ brush_origin = QPointF();
+
+ QPainterPath p;
+ p.addRect(r);
+ fillPath(p);
+
+ cbrush = old_brush;
+ brush_origin = old_brush_origin;
+}
+
+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);
+}
+
+template <typename T>
+static const T qSubImage(const T &image, const QRectF &src, QRectF *srcNew)
+{
+ const int sx1 = qMax(0, qFloor(src.left()));
+ const int sy1 = qMax(0, qFloor(src.top()));
+ const int sx2 = qMin(image.width(), qCeil(src.right()));
+ const int sy2 = qMin(image.height(), qCeil(src.bottom()));
+
+ const T sub = image.copy(sx1, sy1, sx2 - sx1, sy2 - sy1);
+
+ if (srcNew)
+ *srcNew = src.translated(-sx1, -sy1);
+
+ return sub;
+}
+
+void QOpenGLPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+ Q_D(QOpenGLPaintEngine);
+ if (pm.depth() == 1) {
+ QPixmap tpx(pm.size());
+ tpx.fill(Qt::transparent);
+ QPainter p(&tpx);
+ p.setPen(d->cpen);
+ p.drawPixmap(0, 0, pm);
+ p.end();
+ drawPixmap(r, tpx, sr);
+ return;
+ }
+
+ const int sz = d->max_texture_size;
+ if (pm.width() > sz || pm.height() > sz) {
+ QRectF subsr;
+ const QPixmap sub = qSubImage(pm, sr, &subsr);
+
+ if (sub.width() <= sz && sub.height() <= sz) {
+ drawPixmap(r, sub, subsr);
+ } else {
+ const QPixmap scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
+ const qreal sx = scaled.width() / qreal(sub.width());
+ const qreal sy = scaled.height() / qreal(sub.height());
+
+ drawPixmap(r, scaled, scaleRect(subsr, sx, sy));
+ }
+ return;
+ }
+
+
+ if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
+ d->drawImageAsPath(r, pm.toImage(), sr);
+ else {
+ GLenum target = qt_gl_preferredTextureTarget();
+ d->flushDrawQueue();
+ QGLTexture *tex =
+ d->device->context()->d_func()->bindTexture(pm, target, GL_RGBA,
+ QGLContext::InternalBindOption);
+ drawTextureRect(pm.width(), pm.height(), r, sr, target, tex);
+ }
+}
+
+void QOpenGLPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &offset)
+{
+ Q_D(QOpenGLPaintEngine);
+ if (pm.depth() == 1) {
+ QPixmap tpx(pm.size());
+ tpx.fill(Qt::transparent);
+ QPainter p(&tpx);
+ p.setPen(d->cpen);
+ p.drawPixmap(0, 0, pm);
+ p.end();
+ drawTiledPixmap(r, tpx, offset);
+ return;
+ }
+
+ QImage scaled;
+ const int sz = d->max_texture_size;
+ if (pm.width() > sz || pm.height() > sz) {
+ int rw = qCeil(r.width());
+ int rh = qCeil(r.height());
+ if (rw < pm.width() && rh < pm.height()) {
+ drawTiledPixmap(r, pm.copy(0, 0, rw, rh), offset);
+ return;
+ }
+
+ scaled = pm.toImage().scaled(sz, sz, Qt::KeepAspectRatio);
+ }
+
+ if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r))) {
+ if (scaled.isNull())
+ d->drawTiledImageAsPath(r, pm.toImage(), 1, 1, offset);
+ else {
+ const qreal sx = pm.width() / qreal(scaled.width());
+ const qreal sy = pm.height() / qreal(scaled.height());
+ d->drawTiledImageAsPath(r, scaled, sx, sy, offset);
+ }
+ } else {
+ d->flushDrawQueue();
+
+ QGLTexture *tex;
+ if (scaled.isNull())
+ tex = d->device->context()->d_func()->bindTexture(pm, GL_TEXTURE_2D, GL_RGBA,
+ QGLContext::InternalBindOption);
+ else
+ tex = d->device->context()->d_func()->bindTexture(scaled, GL_TEXTURE_2D, GL_RGBA,
+ QGLContext::InternalBindOption);
+ updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, d->use_smooth_pixmap_transform);
+
+#ifndef QT_OPENGL_ES
+ glPushAttrib(GL_CURRENT_BIT);
+ glDisable(GL_TEXTURE_GEN_S);
+#endif
+ glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
+ glEnable(GL_TEXTURE_2D);
+
+ GLdouble tc_w = r.width()/pm.width();
+ GLdouble tc_h = r.height()/pm.height();
+
+ // Rotate the texture so that it is aligned correctly and the
+ // wrapping is done correctly
+ if (tex->options & QGLContext::InvertedYBindOption) {
+ glMatrixMode(GL_TEXTURE);
+ glPushMatrix();
+ glRotatef(180.0, 0.0, 1.0, 0.0);
+ glRotatef(180.0, 0.0, 0.0, 1.0);
+ }
+
+ q_vertexType vertexArray[4*2];
+ q_vertexType texCoordArray[4*2];
+
+ double offset_x = offset.x() / pm.width();
+ double offset_y = offset.y() / pm.height();
+
+ qt_add_rect_to_array(r, vertexArray);
+ qt_add_texcoords_to_array(offset_x, offset_y,
+ tc_w + offset_x, tc_h + offset_y, texCoordArray);
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ if (tex->options & QGLContext::InvertedYBindOption)
+ glPopMatrix();
+
+ glDisable(GL_TEXTURE_2D);
+#ifndef QT_OPENGL_ES
+ glPopAttrib();
+#endif
+ }
+}
+
+void QOpenGLPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
+ Qt::ImageConversionFlags)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ const int sz = d->max_texture_size;
+ if (image.width() > sz || image.height() > sz) {
+ QRectF subsr;
+ const QImage sub = qSubImage(image, sr, &subsr);
+
+ if (sub.width() <= sz && sub.height() <= sz) {
+ drawImage(r, sub, subsr, 0);
+ } else {
+ const QImage scaled = sub.scaled(sz, sz, Qt::KeepAspectRatio);
+ const qreal sx = scaled.width() / qreal(sub.width());
+ const qreal sy = scaled.height() / qreal(sub.height());
+
+ drawImage(r, scaled, scaleRect(subsr, sx, sy), 0);
+ }
+ return;
+ }
+
+ if (d->composition_mode > QPainter::CompositionMode_Plus || (d->high_quality_antialiasing && !d->isFastRect(r)))
+ d->drawImageAsPath(r, image, sr);
+ else {
+ GLenum target = qt_gl_preferredTextureTarget();
+ d->flushDrawQueue();
+ QGLTexture *tex =
+ d->device->context()->d_func()->bindTexture(image, target, GL_RGBA,
+ QGLContext::InternalBindOption);
+ drawTextureRect(image.width(), image.height(), r, sr, target, tex);
+ }
+}
+
+void QOpenGLPaintEngine::drawTextureRect(int tx_width, int tx_height, const QRectF &r,
+ const QRectF &sr, GLenum target, QGLTexture *tex)
+{
+ Q_D(QOpenGLPaintEngine);
+#ifndef QT_OPENGL_ES
+ glPushAttrib(GL_CURRENT_BIT);
+ glDisable(GL_TEXTURE_GEN_S);
+#endif
+ glColor4f(d->opacity, d->opacity, d->opacity, d->opacity);
+ glEnable(target);
+ updateTextureFilter(target, GL_CLAMP_TO_EDGE, d->use_smooth_pixmap_transform);
+
+ qreal x1, x2, y1, y2;
+ if (target == GL_TEXTURE_2D) {
+ x1 = sr.x() / tx_width;
+ x2 = x1 + sr.width() / tx_width;
+ if (tex->options & QGLContext::InvertedYBindOption) {
+ y1 = 1 - (sr.bottom() / tx_height);
+ y2 = 1 - (sr.y() / tx_height);
+ } else {
+ y1 = sr.bottom() / tx_height;
+ y2 = sr.y() / tx_height;
+ }
+ } else {
+ x1 = sr.x();
+ x2 = sr.right();
+ y1 = sr.bottom();
+ y2 = sr.y();
+ }
+
+ q_vertexType vertexArray[4*2];
+ q_vertexType texCoordArray[4*2];
+
+ qt_add_rect_to_array(r, vertexArray);
+ qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray);
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ glDisable(target);
+#ifndef QT_OPENGL_ES
+ glPopAttrib();
+#endif
+}
+
+#ifdef Q_WS_WIN
+HDC
+#else
+Qt::HANDLE
+#endif
+QOpenGLPaintEngine::handle() const
+{
+ return 0;
+}
+
+static const int x_margin = 1;
+static const int y_margin = 0;
+
+struct QGLGlyphCoord {
+ // stores the offset and size of a glyph texture
+ qreal x;
+ qreal y;
+ qreal width;
+ qreal height;
+ qreal log_width;
+ qreal log_height;
+ QFixed x_offset;
+ QFixed y_offset;
+};
+
+struct QGLFontTexture {
+ int x_offset; // glyph offset within the
+ int y_offset;
+ GLuint texture;
+ int width;
+ int height;
+};
+
+typedef QHash<glyph_t, QGLGlyphCoord*> QGLGlyphHash;
+typedef QHash<QFontEngine*, QGLGlyphHash*> QGLFontGlyphHash;
+typedef QHash<quint64, QGLFontTexture*> QGLFontTexHash;
+typedef QHash<const QGLContext*, QGLFontGlyphHash*> QGLContextHash;
+
+class QGLGlyphCache : public QObject
+{
+ Q_OBJECT
+public:
+ QGLGlyphCache() : QObject(0) { current_cache = 0; }
+ ~QGLGlyphCache();
+ QGLGlyphCoord *lookup(QFontEngine *, glyph_t);
+ void cacheGlyphs(QGLContext *, const QTextItemInt &, const QVarLengthArray<glyph_t> &);
+ void cleanCache();
+ void allocTexture(int width, int height, GLuint texture);
+
+public slots:
+ void cleanupContext(const QGLContext *);
+ void fontEngineDestroyed(QObject *);
+ void widgetDestroyed(QObject *);
+
+protected:
+ QGLGlyphHash *current_cache;
+ QGLFontTexHash qt_font_textures;
+ QGLContextHash qt_context_cache;
+};
+
+QGLGlyphCache::~QGLGlyphCache()
+{
+// qDebug() << "cleaning out the QGLGlyphCache";
+ cleanCache();
+}
+
+void QGLGlyphCache::fontEngineDestroyed(QObject *o)
+{
+// qDebug() << "fontEngineDestroyed()";
+ QFontEngine *fe = static_cast<QFontEngine *>(o); // safe, since only the type is used
+ QList<const QGLContext *> keys = qt_context_cache.keys();
+ const QGLContext *ctx = 0;
+
+ for (int i=0; i < keys.size(); ++i) {
+ QGLFontGlyphHash *font_cache = qt_context_cache.value(keys.at(i));
+ if (font_cache->find(fe) != font_cache->end()) {
+ ctx = keys.at(i);
+ QGLGlyphHash *cache = font_cache->take(fe);
+ delete cache;
+ break;
+ }
+ }
+
+ quint64 font_key = (reinterpret_cast<quint64>(ctx) << 32) | reinterpret_cast<quint64>(fe);
+ QGLFontTexture *tex = qt_font_textures.take(font_key);
+ if (tex) {
+#ifdef Q_WS_MAC
+ if (
+# ifndef QT_MAC_USE_COCOA
+ aglGetCurrentContext() != 0
+# else
+ qt_current_nsopengl_context() != 0
+# endif
+ )
+#endif
+ glDeleteTextures(1, &tex->texture);
+ delete tex;
+ }
+}
+
+void QGLGlyphCache::widgetDestroyed(QObject *)
+{
+// qDebug() << "widget destroyed";
+ cleanCache(); // ###
+}
+
+void QGLGlyphCache::cleanupContext(const QGLContext *ctx)
+{
+// qDebug() << "==> cleaning for: " << hex << ctx;
+ QGLFontGlyphHash *font_cache = qt_context_cache.take(ctx);
+
+ if (font_cache) {
+ QList<QFontEngine *> keys = font_cache->keys();
+ for (int i=0; i < keys.size(); ++i) {
+ QFontEngine *fe = keys.at(i);
+ delete font_cache->take(fe);
+ quint64 font_key = (reinterpret_cast<quint64>(ctx) << 32) | reinterpret_cast<quint64>(fe);
+ QGLFontTexture *font_tex = qt_font_textures.take(font_key);
+ if (font_tex) {
+#ifdef Q_WS_MAC
+ if (
+# ifndef QT_MAC_USE_COCOA
+ aglGetCurrentContext() == 0
+# else
+ qt_current_nsopengl_context() != 0
+# endif
+ )
+#endif
+ glDeleteTextures(1, &font_tex->texture);
+ delete font_tex;
+ }
+ }
+ delete font_cache;
+ }
+// qDebug() << "<=== done cleaning, num tex:" << qt_font_textures.size() << "num ctx:" << qt_context_cache.size();
+}
+
+void QGLGlyphCache::cleanCache()
+{
+ QGLFontTexHash::const_iterator it = qt_font_textures.constBegin();
+ if (QGLContext::currentContext()) {
+ while (it != qt_font_textures.constEnd()) {
+#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
+ if (qt_current_nsopengl_context() == 0)
+ break;
+#endif
+ glDeleteTextures(1, &it.value()->texture);
+ ++it;
+ }
+ }
+ qDeleteAll(qt_font_textures);
+ qt_font_textures.clear();
+
+ QList<const QGLContext *> keys = qt_context_cache.keys();
+ for (int i=0; i < keys.size(); ++i) {
+ QGLFontGlyphHash *font_cache = qt_context_cache.value(keys.at(i));
+ qDeleteAll(*font_cache);
+ font_cache->clear();
+ }
+ qDeleteAll(qt_context_cache);
+ qt_context_cache.clear();
+}
+
+void QGLGlyphCache::allocTexture(int width, int height, GLuint texture)
+{
+ uchar *tex_data = (uchar *) malloc(width*height*2);
+ memset(tex_data, 0, width*height*2);
+ glBindTexture(GL_TEXTURE_2D, texture);
+#ifndef QT_OPENGL_ES
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8,
+ width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
+#else
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
+ width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
+#endif
+ free(tex_data);
+}
+
+#if 0
+// useful for debugging the glyph cache
+static QImage getCurrentTexture(const QColor &color, QGLFontTexture *font_tex)
+{
+ ushort *old_tex_data = (ushort *) malloc(font_tex->width*font_tex->height*2);
+ glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
+ QImage im(font_tex->width, font_tex->height, QImage::Format_ARGB32);
+ for (int y=0; y<font_tex->height; ++y) {
+ for (int x=0; x<font_tex->width; ++x) {
+ im.setPixel(x, y, ((*(old_tex_data+x+y*font_tex->width)) << 24) | (0x00ffffff & color.rgb()));
+ }
+ }
+ delete old_tex_data;
+ return im;
+}
+#endif
+
+void QGLGlyphCache::cacheGlyphs(QGLContext *context, const QTextItemInt &ti,
+ const QVarLengthArray<glyph_t> &glyphs)
+{
+ QGLContextHash::const_iterator dev_it = qt_context_cache.constFind(context);
+ QGLFontGlyphHash *font_cache = 0;
+ const QGLContext *context_key = 0;
+
+ if (dev_it == qt_context_cache.constEnd()) {
+ // check for shared contexts
+ QList<const QGLContext *> contexts = qt_context_cache.keys();
+ for (int i=0; i<contexts.size(); ++i) {
+ const QGLContext *ctx = contexts.at(i);
+ if (ctx != context && QGLContext::areSharing(context, ctx)) {
+ context_key = ctx;
+ dev_it = qt_context_cache.constFind(context_key);
+ break;
+ }
+ }
+ }
+
+ if (dev_it == qt_context_cache.constEnd()) {
+ // no shared contexts either - create a new entry
+ font_cache = new QGLFontGlyphHash;
+// qDebug() << "new context" << context << font_cache;
+ qt_context_cache.insert(context, font_cache);
+ if (context->isValid() && context->device()->devType() == QInternal::Widget) {
+ QWidget *widget = static_cast<QWidget *>(context->device());
+ connect(widget, SIGNAL(destroyed(QObject*)), SLOT(widgetDestroyed(QObject*)));
+ connect(QGLSignalProxy::instance(),
+ SIGNAL(aboutToDestroyContext(const QGLContext *)),
+ SLOT(cleanupContext(const QGLContext *)));
+ }
+ } else {
+ font_cache = dev_it.value();
+ }
+ Q_ASSERT(font_cache != 0);
+
+ QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(ti.fontEngine);
+ QGLGlyphHash *cache = 0;
+ if (cache_it == font_cache->constEnd()) {
+ cache = new QGLGlyphHash;
+ font_cache->insert(ti.fontEngine, cache);
+ connect(ti.fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
+ } else {
+ cache = cache_it.value();
+ }
+ current_cache = cache;
+
+ quint64 font_key = (reinterpret_cast<quint64>(context_key ? context_key : context) << 32)
+ | reinterpret_cast<quint64>(ti.fontEngine);
+ QGLFontTexHash::const_iterator it = qt_font_textures.constFind(font_key);
+ QGLFontTexture *font_tex;
+ if (it == qt_font_textures.constEnd()) {
+ GLuint font_texture;
+ glGenTextures(1, &font_texture);
+ GLint tex_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+ GLint tex_width = qt_next_power_of_two(tex_height*30); // ###
+ GLint max_tex_size;
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
+ Q_ASSERT(max_tex_size > 0);
+ if (tex_width > max_tex_size)
+ tex_width = max_tex_size;
+ allocTexture(tex_width, tex_height, font_texture);
+ font_tex = new QGLFontTexture;
+ font_tex->texture = font_texture;
+ font_tex->x_offset = x_margin;
+ font_tex->y_offset = y_margin;
+ font_tex->width = tex_width;
+ font_tex->height = tex_height;
+// qDebug() << "new font tex - width:" << tex_width << "height:"<< tex_height
+// << hex << "tex id:" << font_tex->texture << "key:" << font_key << "num cached:" << qt_font_textures.size();
+ qt_font_textures.insert(font_key, font_tex);
+ } else {
+ font_tex = it.value();
+ glBindTexture(GL_TEXTURE_2D, font_tex->texture);
+ }
+
+ for (int i=0; i< glyphs.size(); ++i) {
+ QGLGlyphHash::const_iterator it = cache->constFind(glyphs[i]);
+ if (it == cache->constEnd()) {
+ // render new glyph and put it in the cache
+ glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyphs[i]);
+ int glyph_width = qRound(metrics.width.toReal())+2;
+ int glyph_height = qRound(ti.ascent.toReal() + ti.descent.toReal())+2;
+
+ if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
+ int strip_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+ font_tex->x_offset = x_margin;
+ font_tex->y_offset += strip_height;
+ if (font_tex->y_offset >= font_tex->height) {
+ // get hold of the old font texture
+ uchar *old_tex_data = (uchar *) malloc(font_tex->width*font_tex->height*2);
+ int old_tex_height = font_tex->height;
+#ifndef QT_OPENGL_ES
+ glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
+#endif
+
+ // realloc a larger texture
+ glDeleteTextures(1, &font_tex->texture);
+ glGenTextures(1, &font_tex->texture);
+ font_tex->height = qt_next_power_of_two(font_tex->height + strip_height);
+ allocTexture(font_tex->width, font_tex->height, font_tex->texture);
+
+ // write back the old texture data
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, font_tex->width, old_tex_height,
+ GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, old_tex_data);
+ free(old_tex_data);
+
+ // update the texture coords and the y offset for the existing glyphs in
+ // the cache, because of the texture size change
+ QGLGlyphHash::iterator it = cache->begin();
+ while (it != cache->end()) {
+ it.value()->height = (it.value()->height * old_tex_height) / font_tex->height;
+ it.value()->y = (it.value()->y * old_tex_height) / font_tex->height;
+ ++it;
+ }
+ }
+ }
+
+ QImage glyph_im(ti.fontEngine->alphaMapForGlyph(glyphs[i]));
+ glyph_im = glyph_im.convertToFormat(QImage::Format_Indexed8);
+ glyph_width = glyph_im.width();
+ Q_ASSERT(glyph_width >= 0);
+ // pad the glyph width to an even number
+ if (glyph_width%2 != 0)
+ ++glyph_width;
+
+ QGLGlyphCoord *qgl_glyph = new QGLGlyphCoord;
+ qgl_glyph->x = qreal(font_tex->x_offset) / font_tex->width;
+ qgl_glyph->y = qreal(font_tex->y_offset) / font_tex->height;
+ qgl_glyph->width = qreal(glyph_width) / font_tex->width;
+ qgl_glyph->height = qreal(glyph_height) / font_tex->height;
+ qgl_glyph->log_width = qreal(glyph_width);
+ qgl_glyph->log_height = qgl_glyph->height * font_tex->height;
+#ifdef Q_WS_MAC
+ qgl_glyph->x_offset = -metrics.x + 1;
+ qgl_glyph->y_offset = metrics.y - 2;
+#else
+ qgl_glyph->x_offset = -metrics.x;
+ qgl_glyph->y_offset = metrics.y;
+#endif
+
+ if (!glyph_im.isNull()) {
+
+ int idx = 0;
+ uchar *tex_data = (uchar *) malloc(glyph_width*glyph_im.height()*2);
+ memset(tex_data, 0, glyph_width*glyph_im.height()*2);
+
+ for (int y=0; y<glyph_im.height(); ++y) {
+ uchar *s = (uchar *) glyph_im.scanLine(y);
+ for (int x=0; x<glyph_im.width(); ++x) {
+ uchar alpha = qAlpha(glyph_im.color(*s));
+ tex_data[idx] = alpha;
+ tex_data[idx+1] = alpha;
+ ++s;
+ idx += 2;
+ }
+ if (glyph_im.width()%2 != 0)
+ idx += 2;
+ }
+ glTexSubImage2D(GL_TEXTURE_2D, 0, font_tex->x_offset, font_tex->y_offset,
+ glyph_width, glyph_im.height(),
+ GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex_data);
+ free(tex_data);
+ }
+ if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
+ font_tex->x_offset = x_margin;
+ font_tex->y_offset += glyph_height + y_margin;
+ } else {
+ font_tex->x_offset += glyph_width + x_margin;
+ }
+
+ cache->insert(glyphs[i], qgl_glyph);
+ }
+ }
+}
+
+QGLGlyphCoord *QGLGlyphCache::lookup(QFontEngine *, glyph_t g)
+{
+ Q_ASSERT(current_cache != 0);
+ // ### careful here
+ QGLGlyphHash::const_iterator it = current_cache->constFind(g);
+ if (it == current_cache->constEnd())
+ return 0;
+ else
+ return it.value();
+}
+
+Q_GLOBAL_STATIC(QGLGlyphCache, qt_glyph_cache)
+
+//
+// assumption: the context that this is called for has to be the
+// current context
+//
+void qgl_cleanup_glyph_cache(QGLContext *ctx)
+{
+ qt_glyph_cache()->cleanupContext(ctx);
+}
+
+void QOpenGLPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+
+ // fall back to drawing a polygon if the scale factor is large, or
+ // we use a gradient pen
+ if ((d->matrix.det() > 1) || (d->pen_brush_style >= Qt::LinearGradientPattern
+ && d->pen_brush_style <= Qt::ConicalGradientPattern)) {
+ QPaintEngine::drawTextItem(p, textItem);
+ return;
+ }
+
+ d->flushDrawQueue();
+
+ // add the glyphs used to the glyph texture cache
+ QVarLengthArray<QFixedPoint> positions;
+ QVarLengthArray<glyph_t> glyphs;
+ QTransform matrix = QTransform::fromTranslate(qRound(p.x()), qRound(p.y()));
+ ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+ // make sure the glyphs we want to draw are in the cache
+ qt_glyph_cache()->cacheGlyphs(d->device->context(), ti, glyphs);
+
+ d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
+ qt_glColor4ubv(d->pen_color);
+ glEnable(GL_TEXTURE_2D);
+
+#ifdef Q_WS_QWS
+ // XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
+ // text rendering to update the alpha in the window surface.
+ // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+#endif
+
+ // do the actual drawing
+ q_vertexType vertexArray[4*2];
+ q_vertexType texCoordArray[4*2];
+
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ bool antialias = !(ti.fontEngine->fontDef.styleStrategy & QFont::NoAntialias);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+
+ for (int i=0; i< glyphs.size(); ++i) {
+ QGLGlyphCoord *g = qt_glyph_cache()->lookup(ti.fontEngine, glyphs[i]);
+
+ // we don't cache glyphs with no width/height
+ if (!g)
+ continue;
+
+ qreal x1, x2, y1, y2;
+ x1 = g->x;
+ y1 = g->y;
+ x2 = x1 + g->width;
+ y2 = y1 + g->height;
+
+ QPointF logical_pos((positions[i].x - g->x_offset).toReal(),
+ (positions[i].y + g->y_offset).toReal());
+
+ qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
+ qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
+
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ }
+
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ glDisable(GL_TEXTURE_2D);
+
+#ifdef Q_WS_QWS
+ // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+#endif
+}
+
+
+void QOpenGLPaintEngine::drawEllipse(const QRectF &rect)
+{
+#ifndef Q_WS_QWS
+ Q_D(QOpenGLPaintEngine);
+
+ if (d->use_emulation) {
+ QPaintEngineEx::drawEllipse(rect);
+ return;
+ }
+
+ if (d->high_quality_antialiasing) {
+ if (d->has_brush) {
+ d->disableClipping();
+
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+
+ GLuint program = qt_gl_program_cache()->getProgram(d->device->context(),
+ FRAGMENT_PROGRAM_MASK_ELLIPSE_AA, 0, true);
+ QGLEllipseMaskGenerator maskGenerator(rect,
+ d->matrix,
+ d->offscreen,
+ program,
+ mask_variable_locations[FRAGMENT_PROGRAM_MASK_ELLIPSE_AA]);
+
+ d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+
+ d->enableClipping();
+
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ }
+
+ if (d->has_pen) {
+ QPainterPath path;
+ path.addEllipse(rect);
+
+ d->strokePath(path, false);
+ }
+ } else {
+ DEBUG_ONCE_STR("QOpenGLPaintEngine::drawEllipse(): falling back to drawPath()");
+
+ QPainterPath path;
+ path.addEllipse(rect);
+ drawPath(path);
+ }
+#else
+ QPaintEngineEx::drawEllipse(rect);
+#endif
+}
+
+
+void QOpenGLPaintEnginePrivate::updateFragmentProgramData(int locations[])
+{
+#ifdef Q_WS_QWS
+ Q_UNUSED(locations);
+#else
+ QGL_FUNC_CONTEXT;
+
+ QSize sz = offscreen.offscreenSize();
+
+ float inv_mask_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
+
+ sz = drawable_texture_size;
+
+ float inv_dst_size_data[4] = { 1.0f / sz.width(), 1.0f / sz.height(), 0.0f, 0.0f };
+
+ // default inv size 0.125f == 1.0f / 8.0f for pattern brushes
+ float inv_brush_texture_size_data[4] = { 0.125f, 0.125f };
+
+ // texture patterns have their own size
+ if (current_style == Qt::TexturePattern) {
+ QSize sz = cbrush.texture().size();
+
+ inv_brush_texture_size_data[0] = 1.0f / sz.width();
+ inv_brush_texture_size_data[1] = 1.0f / sz.height();
+ }
+
+ for (unsigned int i = 0; i < num_fragment_variables; ++i) {
+ int location = locations[i];
+
+ if (location < 0)
+ continue;
+
+ switch (i) {
+ case VAR_ANGLE:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, angle_data);
+ break;
+ case VAR_LINEAR:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, linear_data);
+ break;
+ case VAR_FMP:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp_data);
+ break;
+ case VAR_FMP2_M_RADIUS2:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, fmp2_m_radius2_data);
+ break;
+ case VAR_INV_MASK_SIZE:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_mask_size_data);
+ break;
+ case VAR_INV_DST_SIZE:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_dst_size_data);
+ break;
+ case VAR_INV_MATRIX_M0:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[0]);
+ break;
+ case VAR_INV_MATRIX_M1:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[1]);
+ break;
+ case VAR_INV_MATRIX_M2:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_matrix_data[2]);
+ break;
+ case VAR_PORTERDUFF_AB:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_ab_data);
+ break;
+ case VAR_PORTERDUFF_XYZ:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, porterduff_xyz_data);
+ break;
+ case VAR_INV_BRUSH_TEXTURE_SIZE:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, inv_brush_texture_size_data);
+ break;
+ case VAR_MASK_OFFSET:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_offset_data);
+ break;
+ case VAR_MASK_CHANNEL:
+ glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, location, mask_channel_data);
+ break;
+ case VAR_DST_TEXTURE:
+ case VAR_MASK_TEXTURE:
+ case VAR_PALETTE:
+ case VAR_BRUSH_TEXTURE:
+ // texture variables, not handled here
+ break;
+ default:
+ qDebug() << "QOpenGLPaintEnginePrivate: Unhandled fragment variable:" << i;
+ }
+ }
+#endif
+}
+
+
+void QOpenGLPaintEnginePrivate::copyDrawable(const QRectF &rect)
+{
+#ifdef Q_WS_QWS
+ Q_UNUSED(rect);
+#else
+ ensureDrawableTexture();
+
+ DEBUG_ONCE qDebug() << "Refreshing drawable_texture for rectangle" << rect;
+ QRectF screen_rect = rect.adjusted(-1, -1, 1, 1);
+
+ int left = qMax(0, static_cast<int>(screen_rect.left()));
+ int width = qMin(device->size().width() - left, static_cast<int>(screen_rect.width()) + 1);
+
+ int bottom = qMax(0, static_cast<int>(device->size().height() - screen_rect.bottom()));
+ int height = qMin(device->size().height() - bottom, static_cast<int>(screen_rect.height()) + 1);
+
+ glBindTexture(GL_TEXTURE_2D, drawable_texture);
+ glCopyTexSubImage2D(GL_TEXTURE_2D, 0, left, bottom, left, bottom, width, height);
+#endif
+}
+
+
+void QOpenGLPaintEnginePrivate::composite(const QRectF &rect, const QPoint &maskOffset)
+{
+#ifdef Q_WS_QWS
+ Q_UNUSED(rect);
+ Q_UNUSED(maskOffset);
+#else
+ q_vertexType vertexArray[8];
+ qt_add_rect_to_array(rect, vertexArray);
+
+ composite(GL_TRIANGLE_FAN, vertexArray, 4, maskOffset);
+#endif
+}
+
+
+void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset)
+{
+#ifdef QT_OPENGL_ES
+ Q_UNUSED(primitive);
+ Q_UNUSED(vertexArray);
+ Q_UNUSED(vertexCount);
+ Q_UNUSED(maskOffset);
+#else
+ Q_Q(QOpenGLPaintEngine);
+ QGL_FUNC_CONTEXT;
+
+ if (current_style == Qt::NoBrush)
+ return;
+
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEnginePrivate: Using compositing program: fragment_brush ="
+ << fragment_brush << ", fragment_composition_mode =" << fragment_composition_mode;
+
+ if (has_fast_composition_mode)
+ q->updateCompositionMode(composition_mode);
+ else {
+ qreal minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
+
+ for (int i = 0; i < vertexCount; ++i) {
+ qreal x = vt2f(vertexArray[2 * i]);
+ qreal y = vt2f(vertexArray[2 * i + 1]);
+
+ qreal tx, ty;
+ matrix.map(x, y, &tx, &ty);
+
+ minX = qMin(minX, tx);
+ minY = qMin(minY, ty);
+ maxX = qMax(maxX, tx);
+ maxY = qMax(maxY, ty);
+ }
+
+ QRectF r(minX, minY, maxX - minX, maxY - minY);
+ copyDrawable(r);
+
+ glBlendFunc(GL_ONE, GL_ZERO);
+ }
+
+ int *locations = painter_variable_locations[fragment_brush][fragment_composition_mode];
+
+ int texture_locations[] = { locations[VAR_DST_TEXTURE],
+ locations[VAR_MASK_TEXTURE],
+ locations[VAR_PALETTE] };
+
+ int brush_texture_location = locations[VAR_BRUSH_TEXTURE];
+
+ GLuint texture_targets[] = { GL_TEXTURE_2D,
+ GL_TEXTURE_2D,
+ GL_TEXTURE_1D };
+
+ GLuint textures[] = { drawable_texture,
+ offscreen.offscreenTexture(),
+ grad_palette };
+
+ const int num_textures = sizeof(textures) / sizeof(*textures);
+
+ Q_ASSERT(num_textures == sizeof(texture_locations) / sizeof(*texture_locations));
+ Q_ASSERT(num_textures == sizeof(texture_targets) / sizeof(*texture_targets));
+
+ for (int i = 0; i < num_textures; ++i)
+ if (texture_locations[i] >= 0) {
+ glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
+ glBindTexture(texture_targets[i], textures[i]);
+ }
+
+ if (brush_texture_location >= 0) {
+ glActiveTexture(GL_TEXTURE0 + brush_texture_location);
+
+ if (current_style == Qt::TexturePattern)
+ device->context()->d_func()->bindTexture(cbrush.textureImage(), GL_TEXTURE_2D, GL_RGBA,
+ QGLContext::InternalBindOption);
+ else
+ device->context()->d_func()->bindTexture(qt_imageForBrush(current_style, false),
+ GL_TEXTURE_2D, GL_RGBA,
+ QGLContext::InternalBindOption);
+
+ updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, use_smooth_pixmap_transform);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+ glEnable(GL_FRAGMENT_PROGRAM_ARB);
+ GLuint program = qt_gl_program_cache()->getProgram(device->context(),
+ fragment_brush,
+ fragment_composition_mode, false);
+ glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program);
+
+ mask_offset_data[0] = maskOffset.x();
+ mask_offset_data[1] = -maskOffset.y();
+
+ updateFragmentProgramData(locations);
+
+ glDrawArrays(primitive, 0, vertexCount);
+
+ glDisable(GL_FRAGMENT_PROGRAM_ARB);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ for (int i = 0; i < num_textures; ++i)
+ if (texture_locations[i] >= 0) {
+ glActiveTexture(GL_TEXTURE0 + texture_locations[i]);
+ glBindTexture(texture_targets[i], 0);
+ }
+
+ if (brush_texture_location >= 0) {
+ glActiveTexture(GL_TEXTURE0 + brush_texture_location);
+ glBindTexture(GL_TEXTURE_2D, 0);
+ }
+
+ glActiveTexture(GL_TEXTURE0);
+
+ if (!has_fast_composition_mode)
+ q->updateCompositionMode(composition_mode);
+#endif
+}
+
+void QOpenGLPaintEnginePrivate::cacheItemErased(int channel, const QRect &rect)
+{
+ bool isInDrawQueue = false;
+
+ foreach (const QDrawQueueItem &item, drawQueue) {
+ if (item.location.channel == channel && item.location.rect == rect) {
+ isInDrawQueue = true;
+ break;
+ }
+ }
+
+ if (isInDrawQueue)
+ flushDrawQueue();
+}
+
+void QOpenGLPaintEnginePrivate::addItem(const QGLMaskTextureCache::CacheLocation &location)
+{
+ drawQueue << QDrawQueueItem(opacity, cbrush, brush_origin, composition_mode, matrix, location);
+}
+
+void QOpenGLPaintEnginePrivate::drawItem(const QDrawQueueItem &item)
+{
+ Q_Q(QOpenGLPaintEngine);
+
+ opacity = item.opacity;
+ brush_origin = item.brush_origin;
+ q->updateCompositionMode(item.composition_mode);
+ matrix = item.matrix;
+ cbrush = item.brush;
+ brush_style = item.brush.style();
+
+ mask_channel_data[0] = item.location.channel == 0;
+ mask_channel_data[1] = item.location.channel == 1;
+ mask_channel_data[2] = item.location.channel == 2;
+ mask_channel_data[3] = item.location.channel == 3;
+
+ setGradientOps(item.brush, item.location.screen_rect);
+
+ composite(item.location.screen_rect, item.location.rect.topLeft() - item.location.screen_rect.topLeft()
+ - QPoint(0, offscreen.offscreenSize().height() - device->size().height()));
+}
+
+void QOpenGLPaintEnginePrivate::flushDrawQueue()
+{
+#ifndef QT_OPENGL_ES
+ Q_Q(QOpenGLPaintEngine);
+
+ offscreen.release();
+
+ if (!drawQueue.isEmpty()) {
+ DEBUG_ONCE qDebug() << "QOpenGLPaintEngine::flushDrawQueue():" << drawQueue.size() << "items";
+
+ glPushMatrix();
+ glLoadIdentity();
+ qreal old_opacity = opacity;
+ QPointF old_brush_origin = brush_origin;
+ QPainter::CompositionMode old_composition_mode = composition_mode;
+ QTransform old_matrix = matrix;
+ QBrush old_brush = cbrush;
+
+ bool hqaa_old = high_quality_antialiasing;
+
+ high_quality_antialiasing = true;
+
+ foreach (const QDrawQueueItem &item, drawQueue)
+ drawItem(item);
+
+ opacity = old_opacity;
+ brush_origin = old_brush_origin;
+ q->updateCompositionMode(old_composition_mode);
+ matrix = old_matrix;
+ cbrush = old_brush;
+ brush_style = old_brush.style();
+
+ high_quality_antialiasing = hqaa_old;
+
+ setGLBrush(old_brush.color());
+ qt_glColor4ubv(brush_color);
+
+ drawQueue.clear();
+
+ glPopMatrix();
+ }
+#endif
+}
+
+void QOpenGLPaintEngine::clipEnabledChanged()
+{
+ Q_D(QOpenGLPaintEngine);
+
+ d->updateDepthClip();
+}
+
+void QOpenGLPaintEngine::penChanged()
+{
+ updatePen(state()->pen);
+}
+
+void QOpenGLPaintEngine::brushChanged()
+{
+ updateBrush(state()->brush, state()->brushOrigin);
+}
+
+void QOpenGLPaintEngine::brushOriginChanged()
+{
+ updateBrush(state()->brush, state()->brushOrigin);
+}
+
+void QOpenGLPaintEngine::opacityChanged()
+{
+ Q_D(QOpenGLPaintEngine);
+ QPainterState *s = state();
+ d->opacity = s->opacity;
+ updateBrush(s->brush, s->brushOrigin);
+ updatePen(s->pen);
+}
+
+void QOpenGLPaintEngine::compositionModeChanged()
+{
+ updateCompositionMode(state()->composition_mode);
+}
+
+void QOpenGLPaintEngine::renderHintsChanged()
+{
+ updateRenderHints(state()->renderHints);
+}
+
+void QOpenGLPaintEngine::transformChanged()
+{
+ updateMatrix(state()->matrix);
+}
+
+static QPainterPath painterPathFromVectorPath(const QVectorPath &path)
+{
+ const qreal *points = path.points();
+ const QPainterPath::ElementType *types = path.elements();
+
+ QPainterPath p;
+ if (types) {
+ int id = 0;
+ for (int i=0; i<path.elementCount(); ++i) {
+ switch(types[i]) {
+ case QPainterPath::MoveToElement:
+ p.moveTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ break;
+ case QPainterPath::LineToElement:
+ p.lineTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ break;
+ case QPainterPath::CurveToElement: {
+ QPointF p1(points[id], points[id+1]);
+ QPointF p2(points[id+2], points[id+3]);
+ QPointF p3(points[id+4], points[id+5]);
+ p.cubicTo(p1, p2, p3);
+ id+=6;
+ break;
+ }
+ case QPainterPath::CurveToDataElement:
+ ;
+ break;
+ }
+ }
+ } else {
+ p.moveTo(QPointF(points[0], points[1]));
+ int id = 2;
+ for (int i=1; i<path.elementCount(); ++i) {
+ p.lineTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ }
+ }
+ if (path.hints() & QVectorPath::WindingFill)
+ p.setFillRule(Qt::WindingFill);
+
+ return p;
+}
+
+void QOpenGLPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+ Q_D(QOpenGLPaintEngine);
+
+ if (brush.style() == Qt::NoBrush)
+ return;
+
+ if (!d->use_fragment_programs && needsEmulation(brush.style())) {
+ QPainter *p = painter();
+ QBrush oldBrush = p->brush();
+ p->setBrush(brush);
+ qt_draw_helper(p->d_ptr.data(), painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
+ p->setBrush(oldBrush);
+ return;
+ }
+
+ QBrush old_brush = state()->brush;
+ updateBrush(brush, state()->brushOrigin);
+
+ const qreal *points = path.points();
+ const QPainterPath::ElementType *types = path.elements();
+ if (!types && path.shape() == QVectorPath::RectangleHint) {
+ QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
+ QPen old_pen = state()->pen;
+ updatePen(Qt::NoPen);
+ drawRects(&r, 1);
+ updatePen(old_pen);
+ } else {
+ d->fillPath(painterPathFromVectorPath(path));
+ }
+
+ updateBrush(old_brush, state()->brushOrigin);
+}
+
+template <typename T> static inline bool isRect(const T *pts, int elementCount) {
+ return (elementCount == 5 // 5-point polygon, check for closed rect
+ && pts[0] == pts[8] && pts[1] == pts[9] // last point == first point
+ && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+ && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+ ) ||
+ (elementCount == 4 // 4-point polygon, check for unclosed rect
+ && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+ && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+ );
+}
+
+void QOpenGLPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+ const qreal *points = path.points();
+ const QPainterPath::ElementType *types = path.elements();
+ if (!types && path.shape() == QVectorPath::RectangleHint) {
+ QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
+ updateClipRegion(QRegion(r.toRect()), op);
+ return;
+ }
+
+ QPainterPath p;
+ if (types) {
+ int id = 0;
+ for (int i=0; i<path.elementCount(); ++i) {
+ switch(types[i]) {
+ case QPainterPath::MoveToElement:
+ p.moveTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ break;
+ case QPainterPath::LineToElement:
+ p.lineTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ break;
+ case QPainterPath::CurveToElement: {
+ QPointF p1(points[id], points[id+1]);
+ QPointF p2(points[id+2], points[id+3]);
+ QPointF p3(points[id+4], points[id+5]);
+ p.cubicTo(p1, p2, p3);
+ id+=6;
+ break;
+ }
+ case QPainterPath::CurveToDataElement:
+ ;
+ break;
+ }
+ }
+ } else if (!path.isEmpty()) {
+ p.moveTo(QPointF(points[0], points[1]));
+ int id = 2;
+ for (int i=1; i<path.elementCount(); ++i) {
+ p.lineTo(QPointF(points[id], points[id+1]));
+ id+=2;
+ }
+ }
+ if (path.hints() & QVectorPath::WindingFill)
+ p.setFillRule(Qt::WindingFill);
+
+ updateClipRegion(QRegion(p.toFillPolygon().toPolygon(), p.fillRule()), op);
+ return;
+}
+
+void QOpenGLPaintEngine::setState(QPainterState *s)
+{
+ Q_D(QOpenGLPaintEngine);
+ QOpenGLPaintEngineState *new_state = static_cast<QOpenGLPaintEngineState *>(s);
+ QOpenGLPaintEngineState *old_state = state();
+
+ QPaintEngineEx::setState(s);
+
+ // are we in a save() ?
+ if (s == d->last_created_state) {
+ d->last_created_state = 0;
+ return;
+ }
+
+ if (isActive()) {
+ if (old_state->depthClipId != new_state->depthClipId)
+ d->updateDepthClip();
+ penChanged();
+ brushChanged();
+ opacityChanged();
+ compositionModeChanged();
+ renderHintsChanged();
+ transformChanged();
+ }
+}
+
+QPainterState *QOpenGLPaintEngine::createState(QPainterState *orig) const
+{
+ const Q_D(QOpenGLPaintEngine);
+
+ QOpenGLPaintEngineState *s;
+ if (!orig)
+ s = new QOpenGLPaintEngineState();
+ else
+ s = new QOpenGLPaintEngineState(*static_cast<QOpenGLPaintEngineState *>(orig));
+
+ d->last_created_state = s;
+ return s;
+}
+
+//
+// QOpenGLPaintEngineState
+//
+
+QOpenGLPaintEngineState::QOpenGLPaintEngineState(QOpenGLPaintEngineState &other)
+ : QPainterState(other)
+{
+ clipRegion = other.clipRegion;
+ hasClipping = other.hasClipping;
+ fastClip = other.fastClip;
+ depthClipId = other.depthClipId;
+}
+
+QOpenGLPaintEngineState::QOpenGLPaintEngineState()
+{
+ hasClipping = false;
+ depthClipId = 0;
+}
+
+QOpenGLPaintEngineState::~QOpenGLPaintEngineState()
+{
+}
+
+void QOpenGLPaintEnginePrivate::ensureDrawableTexture()
+{
+ if (!dirty_drawable_texture)
+ return;
+
+ dirty_drawable_texture = false;
+
+#ifndef QT_OPENGL_ES
+ glGenTextures(1, &drawable_texture);
+ glBindTexture(GL_TEXTURE_2D, drawable_texture);
+
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
+ drawable_texture_size.width(),
+ drawable_texture_size.height(), 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+#endif
+}
+
+QT_END_NAMESPACE
+
+#include "qpaintengine_opengl.moc"