diff options
Diffstat (limited to 'src/opengl/qpaintengine_opengl.cpp')
| -rw-r--r-- | src/opengl/qpaintengine_opengl.cpp | 5680 |
1 files changed, 5680 insertions, 0 deletions
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp new file mode 100644 index 0000000000..9da811a9d0 --- /dev/null +++ b/src/opengl/qpaintengine_opengl.cpp @@ -0,0 +1,5680 @@ +/**************************************************************************** +** +** Copyright (C) 2011 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/qstatictext_p.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 + +#define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context()); + +#include <stdlib.h> +#include "qpaintengine_opengl_p.h" + +QT_BEGIN_NAMESPACE + +Q_GUI_EXPORT 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 + +#ifdef Q_WS_X11 +static bool qt_nvidiaFboNeedsFinish = false; +#endif + +static inline void qt_glColor4ubv(unsigned char *col) +{ + glColor4f(col[0]/255.0f, col[1]/255.0f, col[2]/255.0f, col[3]/255.0f); +} + +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 (qt_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 + +struct GLProgram { + int brush; // brush index or mask index + int mode; // composition mode index + bool mask; + GLuint program; +}; + +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) + , tess_points(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 GLfloat *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()); + stroker.setDashOffset(cpen.dashOffset()); + + 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); + +#ifdef Q_WS_X11 + static bool nvidia_workaround_needs_init = true; + if (nvidia_workaround_needs_init) { + // nvidia 9x.xx unix drivers contain a bug which requires us to + // call glFinish before releasing an fbo to avoid painting + // artifacts + const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION))); + const int pos = versionString.indexOf("NVIDIA"); + if (pos >= 0) { + const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat(); + qt_nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0; + } + nvidia_workaround_needs_init = false; + } +#endif + +#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(); + +#if defined(Q_WS_X11) + // clear out the references we hold for textures bound with the + // texture_from_pixmap extension + ctx->d_func()->boundPixmaps.clear(); +#endif + 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); } + GLfloat *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 = (GLfloat *)realloc(vertices, allocated * sizeof(GLfloat)); + } + + QGLTrapezoid t = toGLTrapezoid(trap); + +#ifndef QT_OPENGL_ES + vertices[size++] = t.topLeftX; + vertices[size++] = t.top; + vertices[size++] = t.topRightX; + vertices[size++] = t.top; + vertices[size++] = t.bottomRightX; + vertices[size++] = t.bottom; + vertices[size++] = t.bottomLeftX; + vertices[size++] = t.bottom; +#else + // First triangle + vertices[size++] = t.topLeftX; + vertices[size++] = t.top; + vertices[size++] = t.topRightX; + vertices[size++] = t.top; + vertices[size++] = t.bottomRightX; + vertices[size++] = t.bottom; + + // Second triangle + vertices[size++] = t.bottomLeftX; + vertices[size++] = t.bottom; + vertices[size++] = t.topLeftX; + vertices[size++] = t.top; + vertices[size++] = t.bottomRightX; + vertices[size++] = 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, GL_FLOAT, 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() +{ + if (tess_points_stops.count() == 0) + return; + 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) + 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<GLfloat> clipVertex(rects.size()*2*3*2); + for (int i = 0; i < rects.size(); ++i) { + GLfloat x = GLfloat(rects.at(i).left()); + GLfloat w = GLfloat(rects.at(i).width()); + GLfloat h = GLfloat(rects.at(i).height()); + GLfloat y = GLfloat(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, GL_FLOAT, 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, GLfloat *array); +extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *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, GL_FLOAT, 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] = { { float(inv_matrix.m11()), float(inv_matrix.m12()), float(inv_matrix.m13()) }, + { float(inv_matrix.m21()), float(inv_matrix.m22()), float(inv_matrix.m23()) }, + { float(inv_matrix.m31()), float(inv_matrix.m32()), float(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] = { float(offs.x()), float(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, GL_FLOAT, 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"); + + GLfloat 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, GL_FLOAT, 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, GL_FLOAT, 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(GLfloat *quad, GLfloat *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<GLfloat> 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]); + + GLfloat x = GLfloat(qRound(mapped.x())); + GLfloat y = GLfloat(qRound(mapped.y())); + + vertexArray[j++] = x; + vertexArray[j++] = y - 0.5f; + + vertexArray[j++] = x + 1.5f; + vertexArray[j++] = y + 1.0f; + + vertexArray[j++] = x; + vertexArray[j++] = y + 1.0f; + } + + glEnableClientState(GL_VERTEX_ARRAY); + + glVertexPointer(2, GL_FLOAT, 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, GL_FLOAT, 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; + } + } + } + + GLfloat endCap = d->cpen.capStyle() == Qt::FlatCap ? 0.0f : 0.5f; + if (useRects) { + QVarLengthArray<GLfloat> vertexArray(12 * lineCount); + + GLfloat quad[8]; + for (int i = 0; i < lineCount; ++i) { + GLfloat x1 = lines[i].x1(); + GLfloat x2 = lines[i].x2(); + GLfloat y1 = lines[i].y1(); + GLfloat y2 = lines[i].y2(); + + if (x1 == x2) { + if (y1 > y2) + qSwap(y1, y2); + + quad[0] = x1 - 0.5f; + quad[1] = y1 - endCap; + + quad[2] = x1 + 0.5f; + quad[3] = y1 - endCap; + + quad[4] = x1 + 0.5f; + quad[5] = y2 + endCap; + + quad[6] = x1 - 0.5f; + quad[7] = y2 + endCap; + } else { + if (x1 > x2) + qSwap(x1, x2); + + quad[0] = x1 - endCap; + quad[1] = y1 + 0.5f; + + quad[2] = x1 - endCap; + quad[3] = y1 - 0.5f; + + quad[4] = x2 + endCap; + quad[5] = y1 - 0.5f; + + quad[6] = x2 + endCap; + quad[7] = y1 + 0.5f; + } + + addQuadAsTriangle(quad, &vertexArray[12*i]); + } + + glEnableClientState(GL_VERTEX_ARRAY); + + glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData()); + glDrawArrays(GL_TRIANGLES, 0, lineCount*6); + + glDisableClientState(GL_VERTEX_ARRAY); + } else { + QVarLengthArray<GLfloat> vertexArray(4 * lineCount); + for (int i = 0; i < lineCount; ++i) { + const QPointF a = lines[i].p1(); + vertexArray[4*i] = lines[i].x1(); + vertexArray[4*i+1] = lines[i].y1(); + vertexArray[4*i+2] = lines[i].x2(); + vertexArray[4*i+3] = lines[i].y2(); + } + + glEnableClientState(GL_VERTEX_ARRAY); + + glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData()); + glDrawArrays(GL_LINES, 0, lineCount*2); + + glVertexPointer(2, GL_FLOAT, 4*sizeof(GLfloat), 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, GL_FLOAT, 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<GLfloat> vertexArray(pointCount*2 + 2); + glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData()); + int i; + for (i=0; i<pointCount; ++i) { + vertexArray[i*2] = points[i].x(); + vertexArray[i*2+1] = 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(); +} + +Q_GUI_EXPORT 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, GL_FLOAT, 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, GL_FLOAT, 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); + } + + GLfloat vertexArray[4*2]; + GLfloat 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, GL_FLOAT, 0, vertexArray); + glTexCoordPointer(2, GL_FLOAT, 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(); + } + + GLfloat vertexArray[4*2]; + GLfloat texCoordArray[4*2]; + + qt_add_rect_to_array(r, vertexArray); + qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray); + + glVertexPointer(2, GL_FLOAT, 0, vertexArray); + glTexCoordPointer(2, GL_FLOAT, 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; + +static inline void qt_delete_glyph_hash(QGLGlyphHash *hash) +{ + qDeleteAll(*hash); + delete hash; +} + +class QGLGlyphCache : public QObject +{ + Q_OBJECT +public: + QGLGlyphCache() : QObject(0) { current_cache = 0; } + ~QGLGlyphCache(); + QGLGlyphCoord *lookup(QFontEngine *, glyph_t); + void cacheGlyphs(QGLContext *, QFontEngine *, glyph_t *glyphs, int numGlyphs); + 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); + qt_delete_glyph_hash(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); + qt_delete_glyph_hash(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)); + QGLFontGlyphHash::Iterator it = font_cache->begin(); + for (; it != font_cache->end(); ++it) + qt_delete_glyph_hash(it.value()); + 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, QFontEngine *fontEngine, + glyph_t *glyphs, int numGlyphs) +{ + 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()) { + if (context->device() && 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(fontEngine); + QGLGlyphHash *cache = 0; + if (cache_it == font_cache->constEnd()) { + cache = new QGLGlyphHash; + font_cache->insert(fontEngine, cache); + connect(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>(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(fontEngine->ascent().toReal() + fontEngine->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< numGlyphs; ++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 = fontEngine->boundingBox(glyphs[i]); + int glyph_width = qRound(metrics.width.toReal())+2; + int glyph_height = qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2; + + if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) { + int strip_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->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(fontEngine->alphaMapForGlyph(glyphs[i])); + 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); + + bool is8BitGray = false; +#ifdef Q_WS_QPA + if (glyph_im.format() == QImage::Format_Indexed8) { + is8BitGray = true; + } +#endif + glyph_im = glyph_im.convertToFormat(QImage::Format_Indexed8); + 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 = is8BitGray ? *s : 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::drawStaticTextItem(QStaticTextItem *textItem) +{ + Q_D(QOpenGLPaintEngine); + + d->flushDrawQueue(); + + // make sure the glyphs we want to draw are in the cache + qt_glyph_cache()->cacheGlyphs(d->device->context(), textItem->fontEngine(), textItem->glyphs, + textItem->numGlyphs); + + 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 + GLfloat vertexArray[4*2]; + GLfloat texCoordArray[4*2]; + + glVertexPointer(2, GL_FLOAT, 0, vertexArray); + glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray); + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + bool antialias = !(textItem->fontEngine()->fontDef.styleStrategy & QFont::NoAntialias) + && (d->matrix.type() > QTransform::TxTranslate); + 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< textItem->numGlyphs; ++i) { + QGLGlyphCoord *g = qt_glyph_cache()->lookup(textItem->fontEngine(), textItem->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((textItem->glyphPositions[i].x - g->x_offset).toReal(), + (textItem->glyphPositions[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::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; + } + + // 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); + + { + QStaticTextItem staticTextItem; + staticTextItem.chars = const_cast<QChar *>(ti.chars); + staticTextItem.setFontEngine(ti.fontEngine); + staticTextItem.glyphs = glyphs.data(); + staticTextItem.numChars = ti.num_chars; + staticTextItem.numGlyphs = glyphs.size(); + staticTextItem.glyphPositions = positions.data(); + drawStaticTextItem(&staticTextItem); + } + +} + + +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 + GLfloat vertexArray[8]; + qt_add_rect_to_array(rect, vertexArray); + + composite(GL_TRIANGLE_FAN, vertexArray, 4, maskOffset); +#endif +} + + +void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const GLfloat *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 = vertexArray[2 * i]; + qreal y = 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, GL_FLOAT, 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" |