QGL2PaintEngineExPrivate Class Reference

#include <qpaintengineex_opengl2_p.h>

Inheritance diagram for QGL2PaintEngineExPrivate:

Public Types
enum	StencilFillMode { OddEvenFillMode, WindingFillMode, TriStripStrokeFillMode }

Public Functions
void	clearClip (uint value)
void	composite (const QGLRect &boundingRect)
void	drawCachedGlyphs (QFontEngineGlyphCache::Type glyphType, QStaticTextItem *staticTextItem)
void	drawPixmapFragments (const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, const QSize &size, QPainter::PixmapFragmentHints hints)
void	drawPixmapFragments (const QRectF *targetRects, const QRectF *sourceRects, int fragmentCount, const QPixmap &pixmap, const QSize &size, QPainter::PixmapFragmentHints hints)
void	drawTexture (const QGLRect &dest, const QGLRect &src, const QSize &textureSize, bool opaque, bool pattern=false)
void	drawVertexArrays (const float *data, int *stops, int stopCount, GLenum primitive)
void	drawVertexArrays (QGL2PEXVertexArray &vertexArray, GLenum primitive)
void	fill (const QVectorPath &path)
void	fillStencilWithVertexArray (const float *data, int count, int *stops, int stopCount, const QGLRect &bounds, StencilFillMode mode)
void	fillStencilWithVertexArray (QGL2PEXVertexArray &vertexArray, bool useWindingFill)
GLuint	location (const QGLEngineShaderManager::Uniform uniform)
bool	prepareForDraw (bool srcPixelsAreOpaque)
	QGL2PaintEngineExPrivate (QGL2PaintEngineEx *q_ptr)
void	regenerateClip ()
void	resetClipIfNeeded ()
void	resetGLState ()
void	setBrush (const QBrush &brush)
void	setScissor (const QRect &rect)
void	setVertexAttributePointer (unsigned int arrayIndex, const GLfloat *pointer)
void	stroke (const QVectorPath &path, const QPen &pen)
void	systemStateChanged ()
void	transferMode (EngineMode newMode)
void	updateBrushTexture ()
void	updateBrushUniforms ()
void	updateClipScissorTest ()
void	updateCompositionMode ()
void	updateMatrix ()
void	updateTextureFilter (GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id=-1)
void	useSimpleShader ()
void	writeClip (const QVectorPath &path, uint value)
	~QGL2PaintEngineExPrivate ()
Public Functions inherited from QPaintEngineExPrivate
bool	hasClipOperations () const
	QPaintEngineExPrivate ()
void	replayClipOperations ()
	~QPaintEngineExPrivate ()
Public Functions inherited from QPaintEnginePrivate
void	drawBoxTextItem (const QPointF &p, const QTextItemInt &ti)
	QPaintEnginePrivate ()
void	setSystemTransform (const QTransform &xform)
void	setSystemViewport (const QRegion &region)
void	transformSystemClip ()
virtual	~QPaintEnginePrivate ()

Static Public Functions
static void	cleanupVectorPath (QPaintEngineEx *engine, void *data)
static QGL2PaintEngineExPrivate *	getData (QGL2PaintEngineEx *engine)
static QGLEngineShaderManager *	shaderManagerForEngine (QGL2PaintEngineEx *engine)

Public Variables
QScopedPointer< QPixmapFilter >	blurFilter
bool	brushTextureDirty
bool	brushUniformsDirty
QScopedPointer< QPixmapFilter >	colorizeFilter
bool	compositionModeDirty
QScopedPointer< QPixmapFilter >	convolutionFilter
QGLContext *	ctx
QBrush	currentBrush
QPixmap	currentBrushPixmap
QRect	currentScissorBounds
QDashedStrokeProcessor	dasher
GLfloat	depthRange [2]
QGLPaintDevice *	device
QRegion	dirtyStencilRegion
QScopedPointer< QPixmapFilter >	dropShadowFilter
QVector< GLushort >	elementIndices
GLuint	elementIndicesVBOId
QFontEngineGlyphCache::Type	glyphCacheType
bool	hasCompatibilityExtension
int	height
bool	imageDrawingMode
GLfloat	inverseScale
GLuint	lastMaskTextureUsed
GLuint	lastTextureUsed
bool	matrixDirty
bool	matrixUniformDirty
uint	maxClip
EngineMode	mode
bool	multisamplingAlwaysEnabled
bool	nativePaintingActive
bool	needsSync
const QBrush	noBrush
QDataBuffer< GLfloat >	opacityArray
bool	opacityUniformDirty
QSet< QVectorPath::CacheEntry * >	pathCaches
GLfloat	pmvMatrix [3][3]
QGL2PaintEngineEx *	q
QGLEngineShaderManager *	shaderManager
bool	snapToPixelGrid
GLfloat	staticTextureCoordinateArray [8]
GLfloat	staticVertexCoordinateArray [8]
bool	stencilClean
QTriangulatingStroker	stroker
QGL2PEXVertexArray	textureCoordinateArray
float	textureInvertedY
QVector< GLuint >	unusedIBOSToClean
QVector< GLuint >	unusedVBOSToClean
bool	useSystemClip
const GLfloat *	vertexAttribPointers [3]
QGL2PEXVertexArray	vertexCoordinateArray
int	width
Public Variables inherited from QPaintEngineExPrivate
QStrokerOps *	activeStroker
QDashStroker	dasher
QRect	exDeviceRect
StrokeHandler *	strokeHandler
QStroker	stroker
QPen	strokerPen
Public Variables inherited from QPaintEnginePrivate
QWidget *	currentClipWidget
uint	hasSystemTransform: 1
uint	hasSystemViewport: 1
QPaintDevice *	pdev
QPaintEngine *	q_ptr
QRegion	systemClip
QRect	systemRect
QTransform	systemTransform
QRegion	systemViewport

Detailed Description

Definition at line 169 of file qpaintengineex_opengl2_p.h.

Enumerations

StencilFillMode

enum QGL2PaintEngineExPrivate::StencilFillMode

Enumerator
OddEvenFillMode
WindingFillMode
TriStripStrokeFillMode

Definition at line 173 of file qpaintengineex_opengl2_p.h.

                         {
        OddEvenFillMode,
        WindingFillMode,
        TriStripStrokeFillMode
    };

Constructors and Destructors

QGL2PaintEngineExPrivate()

QGL2PaintEngineExPrivate::QGL2PaintEngineExPrivate ( QGL2PaintEngineEx *  q_ptr )

inline

Definition at line 179 of file qpaintengineex_opengl2_p.h.

                                                       :
            q(q_ptr),
            shaderManager(0),
            width(0), height(0),
            ctx(0),
            useSystemClip(true),
            elementIndicesVBOId(0),
            opacityArray(0),
            snapToPixelGrid(false),
            nativePaintingActive(false),
            inverseScale(1),
            lastMaskTextureUsed(0),
            hasCompatibilityExtension(false)
    { }

~QGL2PaintEngineExPrivate()

QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate

(

)

Definition at line 114 of file qpaintengineex_opengl2.cpp.

{
    delete shaderManager;

    while (pathCaches.size()) {
        QVectorPath::CacheEntry *e = *(pathCaches.constBegin());
        e->cleanup(e->engine, e->data);
        e->data = 0;
        e->engine = 0;
    }

    if (elementIndicesVBOId != 0) {
        glDeleteBuffers(1, &elementIndicesVBOId);
        elementIndicesVBOId = 0;
    }
}

Functions

cleanupVectorPath()

void QGL2PaintEngineExPrivate::cleanupVectorPath ( QPaintEngineEx *  engine, void *  data  )

static

Definition at line 705 of file qpaintengineex_opengl2.cpp.

Referenced by fill().

{
    QGL2PEVectorPathCache *c = (QGL2PEVectorPathCache *) data;
#ifdef QT_OPENGL_CACHE_AS_VBOS
    Q_ASSERT(engine->type() == QPaintEngine::OpenGL2);
    static_cast<QGL2PaintEngineEx *>(engine)->d_func()->unusedVBOSToClean << c->vbo;
    if (c->ibo)
        d->unusedIBOSToClean << c->ibo;
#else
    Q_UNUSED(engine);
    qFree(c->vertices);
    qFree(c->indices);
#endif
    delete c;
}

clearClip()

void QGL2PaintEngineExPrivate::clearClip

(

uint

value

)

Definition at line 2317 of file qpaintengineex_opengl2.cpp.

{
    dirtyStencilRegion -= currentScissorBounds;

    glStencilMask(0xff);
    glClearStencil(value);
    glClear(GL_STENCIL_BUFFER_BIT);
    glStencilMask(0x0);

    q->state()->needsClipBufferClear = false;
}

composite()

void QGL2PaintEngineExPrivate::composite

(

const QGLRect &

boundingRect

)

Definition at line 1169 of file qpaintengineex_opengl2.cpp.

Referenced by fill(), fillStencilWithVertexArray(), and resetClipIfNeeded().

{
    setCoords(staticVertexCoordinateArray, boundingRect);
    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}

drawCachedGlyphs()

void QGL2PaintEngineExPrivate::drawCachedGlyphs	(	QFontEngineGlyphCache::Type	glyphType,
		QStaticTextItem *	staticTextItem
	)

Definition at line 1592 of file qpaintengineex_opengl2.cpp.

{
    Q_Q(QGL2PaintEngineEx);

    QOpenGL2PaintEngineState *s = q->state();

    void *cacheKey = const_cast<QGLContext *>(QGLContextPrivate::contextGroup(ctx)->context());
    bool recreateVertexArrays = false;

    QGLTextureGlyphCache *cache =
            (QGLTextureGlyphCache *) staticTextItem->fontEngine()->glyphCache(cacheKey, glyphType, QTransform());
    if (!cache || cache->cacheType() != glyphType || cache->context() == 0) {
        cache = new QGLTextureGlyphCache(ctx, glyphType, QTransform());
        staticTextItem->fontEngine()->setGlyphCache(cacheKey, cache);
        cache->insert(ctx, cache);
        recreateVertexArrays = true;
    }

    if (staticTextItem->userDataNeedsUpdate) {
        recreateVertexArrays = true;
    } else if (staticTextItem->userData() == 0) {
        recreateVertexArrays = true;
    } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
        recreateVertexArrays = true;
    } else {
        QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
        if (userData->glyphType != glyphType) {
            recreateVertexArrays = true;
        } else if (userData->cacheSerialNumber != cache->serialNumber()) {
            recreateVertexArrays = true;
        }
    }

    // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
    // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
    // cache so this text is performed before we test if the cache size has changed.
    if (recreateVertexArrays) {
        cache->setPaintEnginePrivate(this);
        if (!cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
                             staticTextItem->glyphs, staticTextItem->glyphPositions)) {
            // No space for glyphs in cache. We need to reset it and try again.
            cache->clear();
            cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
                            staticTextItem->glyphs, staticTextItem->glyphPositions);
        }
        cache->fillInPendingGlyphs();
    }

    if (cache->width() == 0 || cache->height() == 0)
        return;

    transferMode(TextDrawingMode);

    int margin = cache->glyphMargin();

    GLfloat dx = 1.0 / cache->width();
    GLfloat dy = 1.0 / cache->height();

    // Use global arrays by default
    QGL2PEXVertexArray *vertexCoordinates = &vertexCoordinateArray;
    QGL2PEXVertexArray *textureCoordinates = &textureCoordinateArray;

    if (staticTextItem->useBackendOptimizations) {
        QOpenGLStaticTextUserData *userData = 0;

        if (staticTextItem->userData() == 0
            || staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {

            userData = new QOpenGLStaticTextUserData();
            staticTextItem->setUserData(userData);

        } else {
            userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
        }

        userData->glyphType = glyphType;
        userData->cacheSerialNumber = cache->serialNumber();

        // Use cache if backend optimizations is turned on
        vertexCoordinates = &userData->vertexCoordinateArray;
        textureCoordinates = &userData->textureCoordinateArray;

        QSize size(cache->width(), cache->height());
        if (userData->cacheSize != size) {
            recreateVertexArrays = true;
            userData->cacheSize = size;
        }
    }

    if (recreateVertexArrays) {
        vertexCoordinates->clear();
        textureCoordinates->clear();

        bool supportsSubPixelPositions = staticTextItem->fontEngine()->supportsSubPixelPositions();
        for (int i=0; i<staticTextItem->numGlyphs; ++i) {
            QFixed subPixelPosition;
            if (supportsSubPixelPositions)
                subPixelPosition = cache->subPixelPositionForX(staticTextItem->glyphPositions[i].x);

            QTextureGlyphCache::GlyphAndSubPixelPosition glyph(staticTextItem->glyphs[i], subPixelPosition);

            const QTextureGlyphCache::Coord &c = cache->coords[glyph];
            if (c.isNull())
                continue;

            int x = qFloor(staticTextItem->glyphPositions[i].x) + c.baseLineX - margin;
            int y = qFloor(staticTextItem->glyphPositions[i].y) - c.baseLineY - margin;

            vertexCoordinates->addQuad(QRectF(x, y, c.w, c.h));
            textureCoordinates->addQuad(QRectF(c.x*dx, c.y*dy, c.w * dx, c.h * dy));
        }

        staticTextItem->userDataNeedsUpdate = false;
    }

    int numGlyphs = vertexCoordinates->vertexCount() / 4;
    if (numGlyphs == 0)
        return;

    if (elementIndices.size() < numGlyphs*6) {
        Q_ASSERT(elementIndices.size() % 6 == 0);
        int j = elementIndices.size() / 6 * 4;
        while (j < numGlyphs*4) {
            elementIndices.append(j + 0);
            elementIndices.append(j + 0);
            elementIndices.append(j + 1);
            elementIndices.append(j + 2);
            elementIndices.append(j + 3);
            elementIndices.append(j + 3);

            j += 4;
        }

#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
        if (elementIndicesVBOId == 0)
            glGenBuffers(1, &elementIndicesVBOId);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementIndices.size() * sizeof(GLushort),
                     elementIndices.constData(), GL_STATIC_DRAW);
#endif
    } else {
#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
#endif
    }

    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinates->data());
    setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinates->data());

    if (!snapToPixelGrid) {
        snapToPixelGrid = true;
        matrixDirty = true;
    }

    QBrush pensBrush = q->state()->pen.brush();

    bool srgbFrameBufferEnabled = false;
    if (pensBrush.style() == Qt::SolidPattern &&
        (ctx->d_ptr->extension_flags & QGLExtensions::SRGBFrameBuffer)) {
#if defined(Q_WS_MAC)
        if (glyphType == QFontEngineGlyphCache::Raster_RGBMask)
#elif defined(Q_WS_WIN)
        if (glyphType != QFontEngineGlyphCache::Raster_RGBMask || fontSmoothingApproximately(2.1))
#else
        if (false)
#endif
        {
            QColor c = pensBrush.color();
            qreal red = qt_sRGB_to_linear_RGB(c.redF());
            qreal green = qt_sRGB_to_linear_RGB(c.greenF());
            qreal blue = qt_sRGB_to_linear_RGB(c.blueF());
            c = QColor::fromRgbF(red, green, blue, c.alphaF());
            pensBrush.setColor(c);

            glEnable(FRAMEBUFFER_SRGB_EXT);
            srgbFrameBufferEnabled = true;
        }
    }

    setBrush(pensBrush);

    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
        // Subpixel antialiasing with gamma correction
        QPainter::CompositionMode compMode = q->state()->composition_mode;
        Q_ASSERT(compMode == QPainter::CompositionMode_Source
            || compMode == QPainter::CompositionMode_SourceOver);

        shaderManager->setMaskType(QGLEngineShaderManager::SubPixelMaskPass1);

        if (pensBrush.style() == Qt::SolidPattern) {
            // Solid patterns can get away with only one pass.
            QColor c = pensBrush.color();
            qreal oldOpacity = q->state()->opacity;
            if (compMode == QPainter::CompositionMode_Source) {
                c = qt_premultiplyColor(c, q->state()->opacity);
                q->state()->opacity = 1;
                opacityUniformDirty = true;
            }

            compositionModeDirty = false; // I can handle this myself, thank you very much
            prepareForDraw(false); // Text always causes src pixels to be transparent

            // prepareForDraw() have set the opacity on the current shader, so the opacity state can now be reset.
            if (compMode == QPainter::CompositionMode_Source) {
                q->state()->opacity = oldOpacity;
                opacityUniformDirty = true;
            }

            glEnable(GL_BLEND);
            glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_SRC_COLOR);
            glBlendColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
        } else {
            // Other brush styles need two passes.

            qreal oldOpacity = q->state()->opacity;
            if (compMode == QPainter::CompositionMode_Source) {
                q->state()->opacity = 1;
                opacityUniformDirty = true;
                pensBrush = Qt::white;
                setBrush(pensBrush);
            }

            compositionModeDirty = false; // I can handle this myself, thank you very much
            prepareForDraw(false); // Text always causes src pixels to be transparent
            glEnable(GL_BLEND);
            glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);

            glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
            glBindTexture(GL_TEXTURE_2D, cache->texture());
#if !defined(QT_NO_DEBUG) && defined(QT_OPENGL_ES_2)
            QGLFunctions funcs(QGLContext::currentContext());
            bool npotSupported = funcs.hasOpenGLFeature(QGLFunctions::NPOTTextures);
            bool isNpot = !isPowerOfTwo(cache->width())
                || !isPowerOfTwo(cache->height());
            if (isNpot && !npotSupported) {
                qWarning("GL2 Paint Engine: This system does not support the REPEAT wrap mode for non-power-of-two textures.");
            }
#endif
            updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, false);

#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
            glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
#else
            glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
#endif

            shaderManager->setMaskType(QGLEngineShaderManager::SubPixelMaskPass2);

            if (compMode == QPainter::CompositionMode_Source) {
                q->state()->opacity = oldOpacity;
                opacityUniformDirty = true;
                pensBrush = q->state()->pen.brush();
                setBrush(pensBrush);
            }

            compositionModeDirty = false;
            prepareForDraw(false); // Text always causes src pixels to be transparent
            glEnable(GL_BLEND);
            glBlendFunc(GL_ONE, GL_ONE);
        }
        compositionModeDirty = true;
    } else {
        // Greyscale/mono glyphs

        shaderManager->setMaskType(QGLEngineShaderManager::PixelMask);
        prepareForDraw(false); // Text always causes src pixels to be transparent
    }

    QGLTextureGlyphCache::FilterMode filterMode = (s->matrix.type() > QTransform::TxTranslate)?QGLTextureGlyphCache::Linear:QGLTextureGlyphCache::Nearest;
    if (lastMaskTextureUsed != cache->texture() || cache->filterMode() != filterMode) {

        glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
        if (lastMaskTextureUsed != cache->texture()) {
            glBindTexture(GL_TEXTURE_2D, cache->texture());
            lastMaskTextureUsed = cache->texture();
        }

        if (cache->filterMode() != filterMode) {
            if (filterMode == QGLTextureGlyphCache::Linear) {
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            } else {
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            }
            cache->setFilterMode(filterMode);
        }
    }

#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
    glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#else
    glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
#endif

    if (srgbFrameBufferEnabled)
        glDisable(FRAMEBUFFER_SRGB_EXT);

}

drawPixmapFragments() [1/2]

void QGL2PaintEngineExPrivate::drawPixmapFragments	(	const QPainter::PixmapFragment *	fragments,
		int	fragmentCount,
		const QPixmap &	pixmap,
		const QSize &	size,
		QPainter::PixmapFragmentHints	hints
	)

Definition at line 1939 of file qpaintengineex_opengl2.cpp.

{
    GLfloat dx = 1.0f / size.width();
    GLfloat dy = 1.0f / size.height();

    vertexCoordinateArray.clear();
    textureCoordinateArray.clear();
    opacityArray.reset();

    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    bool allOpaque = true;

    for (int i = 0; i < fragmentCount; ++i) {
        qreal s = 0;
        qreal c = 1;
        if (fragments[i].rotation != 0) {
            s = qFastSin(fragments[i].rotation * Q_PI / 180);
            c = qFastCos(fragments[i].rotation * Q_PI / 180);
        }

        qreal right = 0.5 * fragments[i].scaleX * fragments[i].width;
        qreal bottom = 0.5 * fragments[i].scaleY * fragments[i].height;
        QGLPoint bottomRight(right * c - bottom * s, right * s + bottom * c);
        QGLPoint bottomLeft(-right * c - bottom * s, -right * s + bottom * c);

        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
        vertexCoordinateArray.addVertex(-bottomLeft.x + fragments[i].x, -bottomLeft.y + fragments[i].y);
        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
        vertexCoordinateArray.addVertex(bottomLeft.x + fragments[i].x, bottomLeft.y + fragments[i].y);
        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);

        QGLRect src(fragments[i].sourceLeft * dx, fragments[i].sourceTop * dy,
                    (fragments[i].sourceLeft + fragments[i].width) * dx,
                    (fragments[i].sourceTop + fragments[i].height) * dy);

        textureCoordinateArray.addVertex(src.right, src.bottom);
        textureCoordinateArray.addVertex(src.right, src.top);
        textureCoordinateArray.addVertex(src.left, src.top);
        textureCoordinateArray.addVertex(src.left, src.top);
        textureCoordinateArray.addVertex(src.left, src.bottom);
        textureCoordinateArray.addVertex(src.right, src.bottom);

        qreal opacity = fragments[i].opacity * q->state()->opacity;
        opacityArray << opacity << opacity << opacity << opacity << opacity << opacity;
        allOpaque &= (opacity >= 0.99f);
    }

    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
    QGLTexture *texture = ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA,
                                                     QGLContext::InternalBindOption
                                                     | QGLContext::CanFlipNativePixmapBindOption);

    if (texture->options & QGLContext::InvertedYBindOption) {
        // Flip texture y-coordinate.
        QGLPoint *data = textureCoordinateArray.data();
        for (int i = 0; i < 6 * fragmentCount; ++i)
            data[i].y = 1 - data[i].y;
    }

    transferMode(allOpaque ? ImageArrayDrawingMode : ImageArrayWithOpacityDrawingMode);

    bool isBitmap = pixmap.isQBitmap();
    bool isOpaque = !isBitmap && (!pixmap.hasAlpha() || (hints & QPainter::OpaqueHint)) && allOpaque;

    updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
                           q->state()->renderHints & QPainter::SmoothPixmapTransform, texture->id);

    // Setup for texture drawing
    currentBrush = noBrush;
    shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc
                                            : QGLEngineShaderManager::ImageSrc);
    if (prepareForDraw(isOpaque))
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);

    if (isBitmap) {
        QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
    }

    glDrawArrays(GL_TRIANGLES, 0, 6 * fragmentCount);
}

drawPixmapFragments() [2/2]

void QGL2PaintEngineExPrivate::drawPixmapFragments	(	const QRectF *	targetRects,
		const QRectF *	sourceRects,
		int	fragmentCount,
		const QPixmap &	pixmap,
		const QSize &	size,
		QPainter::PixmapFragmentHints	hints
	)

Definition at line 2028 of file qpaintengineex_opengl2.cpp.

{
    GLfloat dx = 1.0f / size.width();
    GLfloat dy = 1.0f / size.height();

    vertexCoordinateArray.clear();
    textureCoordinateArray.clear();

    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    for (int i = 0; i < fragmentCount; ++i) {
        vertexCoordinateArray.addVertex(targetRects[i].right(), targetRects[i].bottom());
        vertexCoordinateArray.addVertex(targetRects[i].right(), targetRects[i].top());
        vertexCoordinateArray.addVertex(targetRects[i].left(), targetRects[i].top());
        vertexCoordinateArray.addVertex(targetRects[i].left(), targetRects[i].top());
        vertexCoordinateArray.addVertex(targetRects[i].left(), targetRects[i].bottom());
        vertexCoordinateArray.addVertex(targetRects[i].right(), targetRects[i].bottom());

        QRectF sourceRect = sourceRects ? sourceRects[i] : QRectF(0, 0, size.width(), size.height());

        QGLRect src(sourceRect.left() * dx, sourceRect.top() * dy,
                    sourceRect.right() * dx, sourceRect.bottom() * dy);

        textureCoordinateArray.addVertex(src.right, src.bottom);
        textureCoordinateArray.addVertex(src.right, src.top);
        textureCoordinateArray.addVertex(src.left, src.top);
        textureCoordinateArray.addVertex(src.left, src.top);
        textureCoordinateArray.addVertex(src.left, src.bottom);
        textureCoordinateArray.addVertex(src.right, src.bottom);
    }

    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
    QGLTexture *texture = ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA,
                                                     QGLContext::InternalBindOption
                                                     | QGLContext::CanFlipNativePixmapBindOption);

    if (texture->options & QGLContext::InvertedYBindOption) {
        // Flip texture y-coordinate.
        QGLPoint *data = textureCoordinateArray.data();
        for (int i = 0; i < 6 * fragmentCount; ++i)
            data[i].y = 1 - data[i].y;
    }

    transferMode(ImageArrayDrawingMode);

    bool isBitmap = pixmap.isQBitmap();
    bool isOpaque = !isBitmap && (!pixmap.hasAlpha() || (hints & QPainter::OpaqueHint));

    updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
                           q->state()->renderHints & QPainter::SmoothPixmapTransform, texture->id);

    // Setup for texture drawing
    currentBrush = noBrush;
    shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc
                                            : QGLEngineShaderManager::ImageSrc);
    if (prepareForDraw(isOpaque))
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);

    if (isBitmap) {
        QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
    }

    glDrawArrays(GL_TRIANGLES, 0, 6 * fragmentCount);
}

drawTexture()

void QGL2PaintEngineExPrivate::drawTexture	(	const QGLRect &	dest,
		const QGLRect &	src,
		const QSize &	textureSize,
		bool	opaque,
		bool	pattern = false
	)

Definition at line 523 of file qpaintengineex_opengl2.cpp.

{
    // Setup for texture drawing
    currentBrush = noBrush;
    shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc);

    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    if (prepareForDraw(opaque))
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);

    if (pattern) {
        QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
    }

    GLfloat dx = 1.0 / textureSize.width();
    GLfloat dy = 1.0 / textureSize.height();

    QGLRect srcTextureRect(src.left*dx, src.top*dy, src.right*dx, src.bottom*dy);

    setCoords(staticVertexCoordinateArray, dest);
    setCoords(staticTextureCoordinateArray, srcTextureRect);

    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}

drawVertexArrays() [1/2]

void QGL2PaintEngineExPrivate::drawVertexArrays	(	const float *	data,
		int *	stops,
		int	stopCount,
		GLenum	primitive
	)

Definition at line 1177 of file qpaintengineex_opengl2.cpp.

Referenced by fill(), and fillStencilWithVertexArray().

{
    // Now setup the pointer to the vertex array:
    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)data);

    int previousStop = 0;
    for (int i=0; i<stopCount; ++i) {
        int stop = stops[i];
/*
        qDebug("Drawing triangle fan for vertecies %d -> %d:", previousStop, stop-1);
        for (int i=previousStop; i<stop; ++i)
            qDebug("   %02d: [%.2f, %.2f]", i, vertexArray.data()[i].x, vertexArray.data()[i].y);
*/
        glDrawArrays(primitive, previousStop, stop - previousStop);
        previousStop = stop;
    }
}

drawVertexArrays() [2/2]

void QGL2PaintEngineExPrivate::drawVertexArrays ( QGL2PEXVertexArray &  vertexArray, GLenum  primitive  )

inline

Definition at line 220 of file qpaintengineex_opengl2_p.h.

                                                                             {
        drawVertexArrays((const float *) vertexArray.data(), vertexArray.stops(), vertexArray.stopCount(), primitive);
    }

fill()

void QGL2PaintEngineExPrivate::fill

(

const QVectorPath &

path

)

Definition at line 722 of file qpaintengineex_opengl2.cpp.

{
    transferMode(BrushDrawingMode);

    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    // Might need to call updateMatrix to re-calculate inverseScale
    if (matrixDirty)
        updateMatrix();

    const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());

    // Check to see if there's any hints
    if (path.shape() == QVectorPath::RectangleHint) {
        QGLRect rect(points[0].x(), points[0].y(), points[2].x(), points[2].y());
        prepareForDraw(currentBrush.isOpaque());
        composite(rect);
    } else if (path.isConvex()) {

        if (path.isCacheable()) {
            QVectorPath::CacheEntry *data = path.lookupCacheData(q);
            QGL2PEVectorPathCache *cache;

            bool updateCache = false;

            if (data) {
                cache = (QGL2PEVectorPathCache *) data->data;
                // Check if scale factor is exceeded for curved paths and generate curves if so...
                if (path.isCurved()) {
                    qreal scaleFactor = cache->iscale / inverseScale;
                    if (scaleFactor < 0.5 || scaleFactor > 2.0) {
#ifdef QT_OPENGL_CACHE_AS_VBOS
                        glDeleteBuffers(1, &cache->vbo);
                        cache->vbo = 0;
                        Q_ASSERT(cache->ibo == 0);
#else
                        qFree(cache->vertices);
                        Q_ASSERT(cache->indices == 0);
#endif
                        updateCache = true;
                    }
                }
            } else {
                cache = new QGL2PEVectorPathCache;
                data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
                updateCache = true;
            }

            // Flatten the path at the current scale factor and fill it into the cache struct.
            if (updateCache) {
                vertexCoordinateArray.clear();
                vertexCoordinateArray.addPath(path, inverseScale, false);
                int vertexCount = vertexCoordinateArray.vertexCount();
                int floatSizeInBytes = vertexCount * 2 * sizeof(float);
                cache->vertexCount = vertexCount;
                cache->indexCount = 0;
                cache->primitiveType = GL_TRIANGLE_FAN;
                cache->iscale = inverseScale;
#ifdef QT_OPENGL_CACHE_AS_VBOS
                glGenBuffers(1, &cache->vbo);
                glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
                glBufferData(GL_ARRAY_BUFFER, floatSizeInBytes, vertexCoordinateArray.data(), GL_STATIC_DRAW);
                cache->ibo = 0;
#else
                cache->vertices = (float *) qMalloc(floatSizeInBytes);
                memcpy(cache->vertices, vertexCoordinateArray.data(), floatSizeInBytes);
                cache->indices = 0;
#endif
            }

            prepareForDraw(currentBrush.isOpaque());
#ifdef QT_OPENGL_CACHE_AS_VBOS
            glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
#else
            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
#endif
            glDrawArrays(cache->primitiveType, 0, cache->vertexCount);

        } else {
      //        printf(" - Marking path as cachable...\n");
            // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
            path.makeCacheable();
            vertexCoordinateArray.clear();
            vertexCoordinateArray.addPath(path, inverseScale, false);
            prepareForDraw(currentBrush.isOpaque());
            drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
        }

    } else {
        bool useCache = path.isCacheable();
        if (useCache) {
            QRectF bbox = path.controlPointRect();
            // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
            useCache &= (bbox.left() > -0x8000 * inverseScale)
                     && (bbox.right() < 0x8000 * inverseScale)
                     && (bbox.top() > -0x8000 * inverseScale)
                     && (bbox.bottom() < 0x8000 * inverseScale);
        }

        if (useCache) {
            QVectorPath::CacheEntry *data = path.lookupCacheData(q);
            QGL2PEVectorPathCache *cache;

            bool updateCache = false;

            if (data) {
                cache = (QGL2PEVectorPathCache *) data->data;
                // Check if scale factor is exceeded for curved paths and generate curves if so...
                if (path.isCurved()) {
                    qreal scaleFactor = cache->iscale / inverseScale;
                    if (scaleFactor < 0.5 || scaleFactor > 2.0) {
#ifdef QT_OPENGL_CACHE_AS_VBOS
                        glDeleteBuffers(1, &cache->vbo);
                        glDeleteBuffers(1, &cache->ibo);
#else
                        qFree(cache->vertices);
                        qFree(cache->indices);
#endif
                        updateCache = true;
                    }
                }
            } else {
                cache = new QGL2PEVectorPathCache;
                data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
                updateCache = true;
            }

            // Flatten the path at the current scale factor and fill it into the cache struct.
            if (updateCache) {
                QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));
                cache->vertexCount = polys.vertices.size() / 2;
                cache->indexCount = polys.indices.size();
                cache->primitiveType = GL_TRIANGLES;
                cache->iscale = inverseScale;
#ifdef QT_OPENGL_CACHE_AS_VBOS
                glGenBuffers(1, &cache->vbo);
                glGenBuffers(1, &cache->ibo);
                glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);

                if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint32) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
                else
                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint16) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);

                QVarLengthArray<float> vertices(polys.vertices.size());
                for (int i = 0; i < polys.vertices.size(); ++i)
                    vertices[i] = float(inverseScale * polys.vertices.at(i));
                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
#else
                cache->vertices = (float *) qMalloc(sizeof(float) * polys.vertices.size());
                if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint) {
                    cache->indices = (quint32 *) qMalloc(sizeof(quint32) * polys.indices.size());
                    memcpy(cache->indices, polys.indices.data(), sizeof(quint32) * polys.indices.size());
                } else {
                    cache->indices = (quint16 *) qMalloc(sizeof(quint16) * polys.indices.size());
                    memcpy(cache->indices, polys.indices.data(), sizeof(quint16) * polys.indices.size());
                }
                for (int i = 0; i < polys.vertices.size(); ++i)
                    cache->vertices[i] = float(inverseScale * polys.vertices.at(i));
#endif
            }

            prepareForDraw(currentBrush.isOpaque());
#ifdef QT_OPENGL_CACHE_AS_VBOS
            glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
            if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, 0);
            else
                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, 0);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
#else
            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
            if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, (qint32 *)cache->indices);
            else
                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, (qint16 *)cache->indices);
#endif

        } else {
      //        printf(" - Marking path as cachable...\n");
            // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
            path.makeCacheable();

            if (!device->format().stencil()) {
                // If there is no stencil buffer, triangulate the path instead.

                QRectF bbox = path.controlPointRect();
                // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
                bool withinLimits = (bbox.left() > -0x8000 * inverseScale)
                                  && (bbox.right() < 0x8000 * inverseScale)
                                  && (bbox.top() > -0x8000 * inverseScale)
                                  && (bbox.bottom() < 0x8000 * inverseScale);
                if (withinLimits) {
                    QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));

                    QVarLengthArray<float> vertices(polys.vertices.size());
                    for (int i = 0; i < polys.vertices.size(); ++i)
                        vertices[i] = float(inverseScale * polys.vertices.at(i));

                    prepareForDraw(currentBrush.isOpaque());
                    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, vertices.constData());
                    if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
                        glDrawElements(GL_TRIANGLES, polys.indices.size(), GL_UNSIGNED_INT, polys.indices.data());
                    else
                        glDrawElements(GL_TRIANGLES, polys.indices.size(), GL_UNSIGNED_SHORT, polys.indices.data());
                } else {
                    // We can't handle big, concave painter paths with OpenGL without stencil buffer.
                    qWarning("Painter path exceeds +/-32767 pixels.");
                }
                return;
            }

            // The path is too complicated & needs the stencil technique
            vertexCoordinateArray.clear();
            vertexCoordinateArray.addPath(path, inverseScale, false);

            fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());

            glStencilMask(0xff);
            glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);

            if (q->state()->clipTestEnabled) {
                // Pass when high bit is set, replace stencil value with current clip
                glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
            } else if (path.hasWindingFill()) {
                // Pass when any bit is set, replace stencil value with 0
                glStencilFunc(GL_NOTEQUAL, 0, 0xff);
            } else {
                // Pass when high bit is set, replace stencil value with 0
                glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
            }
            prepareForDraw(currentBrush.isOpaque());

            // Stencil the brush onto the dest buffer
            composite(vertexCoordinateArray.boundingRect());
            glStencilMask(0);
            updateClipScissorTest();
        }
    }
}

fillStencilWithVertexArray() [1/2]

void QGL2PaintEngineExPrivate::fillStencilWithVertexArray	(	const float *	data,
		int	count,
		int *	stops,
		int	stopCount,
		const QGLRect &	bounds,
		StencilFillMode	mode
	)

Definition at line 972 of file qpaintengineex_opengl2.cpp.

Referenced by fill().

{
    Q_ASSERT(count || stops);

//     qDebug("QGL2PaintEngineExPrivate::fillStencilWithVertexArray()");
    glStencilMask(0xff); // Enable stencil writes

    if (dirtyStencilRegion.intersects(currentScissorBounds)) {
        QVector<QRect> clearRegion = dirtyStencilRegion.intersected(currentScissorBounds).rects();
        glClearStencil(0); // Clear to zero
        for (int i = 0; i < clearRegion.size(); ++i) {
#ifndef QT_GL_NO_SCISSOR_TEST
            setScissor(clearRegion.at(i));
#endif
            glClear(GL_STENCIL_BUFFER_BIT);
        }

        dirtyStencilRegion -= currentScissorBounds;

#ifndef QT_GL_NO_SCISSOR_TEST
        updateClipScissorTest();
#endif
    }

    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Disable color writes
    useSimpleShader();
    glEnable(GL_STENCIL_TEST); // For some reason, this has to happen _after_ the simple shader is use()'d

    if (mode == WindingFillMode) {
        Q_ASSERT(stops && !count);
        if (q->state()->clipTestEnabled) {
            // Flatten clip values higher than current clip, and set high bit to match current clip
            glStencilFunc(GL_LEQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
            glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
            composite(bounds);

            glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT, GL_STENCIL_HIGH_BIT);
        } else if (!stencilClean) {
            // Clear stencil buffer within bounding rect
            glStencilFunc(GL_ALWAYS, 0, 0xff);
            glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
            composite(bounds);
        }

        // Inc. for front-facing triangle
        glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_INCR_WRAP);
        // Dec. for back-facing "holes"
        glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_DECR_WRAP);
        glStencilMask(~GL_STENCIL_HIGH_BIT);
        drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);

        if (q->state()->clipTestEnabled) {
            // Clear high bit of stencil outside of path
            glStencilFunc(GL_EQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
            glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
            glStencilMask(GL_STENCIL_HIGH_BIT);
            composite(bounds);
        }
    } else if (mode == OddEvenFillMode) {
        glStencilMask(GL_STENCIL_HIGH_BIT);
        glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
        drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);

    } else { // TriStripStrokeFillMode
        Q_ASSERT(count && !stops); // tristrips generated directly, so no vertexArray or stops
        glStencilMask(GL_STENCIL_HIGH_BIT);
#if 0
        glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
#else

        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
        if (q->state()->clipTestEnabled) {
            glStencilFunc(GL_LEQUAL, q->state()->currentClip | GL_STENCIL_HIGH_BIT,
                          ~GL_STENCIL_HIGH_BIT);
        } else {
            glStencilFunc(GL_ALWAYS, GL_STENCIL_HIGH_BIT, 0xff);
        }
        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
#endif
    }

    // Enable color writes & disable stencil writes
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}

fillStencilWithVertexArray() [2/2]

void QGL2PaintEngineExPrivate::fillStencilWithVertexArray ( QGL2PEXVertexArray &  vertexArray, bool  useWindingFill  )

inline

Definition at line 229 of file qpaintengineex_opengl2_p.h.

                                                                                          {
        fillStencilWithVertexArray((const float *) vertexArray.data(), 0, vertexArray.stops(), vertexArray.stopCount(),
                                   vertexArray.boundingRect(),
                                   useWindingFill ? WindingFillMode : OddEvenFillMode);
    }

getData()

static QGL2PaintEngineExPrivate* QGL2PaintEngineExPrivate::getData ( QGL2PaintEngineEx *  engine )

inlinestatic

Definition at line 254 of file qpaintengineex_opengl2_p.h.

{ return engine->d_func(); }

location()

GLuint QGL2PaintEngineExPrivate::location ( const QGLEngineShaderManager::Uniform  uniform )

inline

Definition at line 239 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), prepareForDraw(), and updateBrushUniforms().

                                                                        {
        return shaderManager->getUniformLocation(uniform);
    }

prepareForDraw()

bool QGL2PaintEngineExPrivate::prepareForDraw

(

bool

srcPixelsAreOpaque

)

Definition at line 1105 of file qpaintengineex_opengl2.cpp.

Referenced by drawTexture(), and fill().

{
    if (brushTextureDirty && !imageDrawingMode)
        updateBrushTexture();

    if (compositionModeDirty)
        updateCompositionMode();

    if (matrixDirty)
        updateMatrix();

    const bool stateHasOpacity = q->state()->opacity < 0.99f;
    if (q->state()->composition_mode == QPainter::CompositionMode_Source
        || (q->state()->composition_mode == QPainter::CompositionMode_SourceOver
            && srcPixelsAreOpaque && !stateHasOpacity))
    {
        glDisable(GL_BLEND);
    } else {
        glEnable(GL_BLEND);
    }

    QGLEngineShaderManager::OpacityMode opacityMode;
    if (mode == ImageArrayWithOpacityDrawingMode) {
        opacityMode = QGLEngineShaderManager::AttributeOpacity;
    } else {
        opacityMode = stateHasOpacity ? QGLEngineShaderManager::UniformOpacity
                                      : QGLEngineShaderManager::NoOpacity;
        if (stateHasOpacity && !imageDrawingMode) {
            // Using a brush
            bool brushIsPattern = (currentBrush.style() >= Qt::Dense1Pattern) &&
                                  (currentBrush.style() <= Qt::DiagCrossPattern);

            if ((currentBrush.style() == Qt::SolidPattern) || brushIsPattern)
                opacityMode = QGLEngineShaderManager::NoOpacity; // Global opacity handled by srcPixel shader
        }
    }
    shaderManager->setOpacityMode(opacityMode);

    bool changed = shaderManager->useCorrectShaderProg();
    // If the shader program needs changing, we change it and mark all uniforms as dirty
    if (changed) {
        // The shader program has changed so mark all uniforms as dirty:
        brushUniformsDirty = true;
        opacityUniformDirty = true;
        matrixUniformDirty = true;
    }

    if (brushUniformsDirty && !imageDrawingMode)
        updateBrushUniforms();

    if (opacityMode == QGLEngineShaderManager::UniformOpacity && opacityUniformDirty) {
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::GlobalOpacity), (GLfloat)q->state()->opacity);
        opacityUniformDirty = false;
    }

    if (matrixUniformDirty && shaderManager->hasComplexGeometry()) {
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Matrix),
                                                         pmvMatrix);
        matrixUniformDirty = false;
    }

    return changed;
}

regenerateClip()

void QGL2PaintEngineExPrivate::regenerateClip

(

)

Definition at line 2500 of file qpaintengineex_opengl2.cpp.

{
    systemStateChanged();
    replayClipOperations();
}

resetClipIfNeeded()

void QGL2PaintEngineExPrivate::resetClipIfNeeded

(

)

Definition at line 1070 of file qpaintengineex_opengl2.cpp.

{
    if (maxClip != (GL_STENCIL_HIGH_BIT - 1))
        return;

    Q_Q(QGL2PaintEngineEx);

    useSimpleShader();
    glEnable(GL_STENCIL_TEST);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

    QRectF bounds = q->state()->matrix.inverted().mapRect(QRectF(0, 0, width, height));
    QGLRect rect(bounds.left(), bounds.top(), bounds.right(), bounds.bottom());

    // Set high bit on clip region
    glStencilFunc(GL_LEQUAL, q->state()->currentClip, 0xff);
    glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
    glStencilMask(GL_STENCIL_HIGH_BIT);
    composite(rect);

    // Reset clipping to 1 and everything else to zero
    glStencilFunc(GL_NOTEQUAL, 0x01, GL_STENCIL_HIGH_BIT);
    glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
    glStencilMask(0xff);
    composite(rect);

    q->state()->currentClip = 1;
    q->state()->canRestoreClip = false;

    maxClip = 1;

    glStencilMask(0x0);
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}

resetGLState()

void QGL2PaintEngineExPrivate::resetGLState

(

)

Definition at line 609 of file qpaintengineex_opengl2.cpp.

{
    glDisable(GL_BLEND);
    glActiveTexture(GL_TEXTURE0);
    glDisable(GL_STENCIL_TEST);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_SCISSOR_TEST);
    glDepthMask(true);
    glDepthFunc(GL_LESS);
    glClearDepth(1);
    glStencilMask(0xff);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
    glStencilFunc(GL_ALWAYS, 0, 0xff);
    ctx->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
    ctx->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, false);
    ctx->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
#ifndef QT_OPENGL_ES_2
    // gl_Color, corresponding to vertex attribute 3, may have been changed
    float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    glVertexAttrib4fv(3, color);
#endif
}

setBrush()

void QGL2PaintEngineExPrivate::setBrush

(

const QBrush &

brush

)

Definition at line 162 of file qpaintengineex_opengl2.cpp.

{
    if (qbrush_fast_equals(currentBrush, brush))
        return;

    const Qt::BrushStyle newStyle = qbrush_style(brush);
    Q_ASSERT(newStyle != Qt::NoBrush);

    currentBrush = brush;
    if (!currentBrushPixmap.isNull())
        currentBrushPixmap = QPixmap();
    brushUniformsDirty = true; // All brushes have at least one uniform

    if (newStyle > Qt::SolidPattern)
        brushTextureDirty = true;

    if (currentBrush.style() == Qt::TexturePattern
        && qHasPixmapTexture(brush) && brush.texture().isQBitmap())
    {
        shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern);
    } else {
        shaderManager->setSrcPixelType(newStyle);
    }
    shaderManager->optimiseForBrushTransform(currentBrush.transform().type());
}

setScissor()

void QGL2PaintEngineExPrivate::setScissor

(

const QRect &

rect

)

Definition at line 2292 of file qpaintengineex_opengl2.cpp.

Referenced by fillStencilWithVertexArray().

{
    const int left = rect.left();
    const int width = rect.width();
    int bottom = height - (rect.top() + rect.height());
    if (device->isFlipped()) {
        bottom = rect.top();
    }
    const int height = rect.height();

    glScissor(left, bottom, width, height);
}

setVertexAttributePointer()

void QGL2PaintEngineExPrivate::setVertexAttributePointer ( unsigned int  arrayIndex, const GLfloat *  pointer  )

inline

Definition at line 327 of file qpaintengineex_opengl2_p.h.

Referenced by composite(), drawVertexArrays(), fill(), fillStencilWithVertexArray(), QGLTextureGlyphCache::resizeTextureData(), and transferMode().

{
    Q_ASSERT(arrayIndex < 3);
    if (pointer == vertexAttribPointers[arrayIndex])
        return;

    vertexAttribPointers[arrayIndex] = pointer;
    if (arrayIndex == QT_OPACITY_ATTR)
        glVertexAttribPointer(arrayIndex, 1, GL_FLOAT, GL_FALSE, 0, pointer);
    else
        glVertexAttribPointer(arrayIndex, 2, GL_FLOAT, GL_FALSE, 0, pointer);
}

shaderManagerForEngine()

static QGLEngineShaderManager* QGL2PaintEngineExPrivate::shaderManagerForEngine ( QGL2PaintEngineEx *  engine )

inlinestatic

Definition at line 253 of file qpaintengineex_opengl2_p.h.

Referenced by QGLCustomShaderStage::removeFromPainter(), and QGLCustomShaderStage::setOnPainter().

{ return engine->d_func()->shaderManager; }

stroke()

void QGL2PaintEngineExPrivate::stroke	(	const QVectorPath &	path,
		const QPen &	pen
	)

Definition at line 1241 of file qpaintengineex_opengl2.cpp.

{
    const QOpenGL2PaintEngineState *s = q->state();
    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    const Qt::PenStyle penStyle = qpen_style(pen);
    const QBrush &penBrush = qpen_brush(pen);
    const bool opaque = penBrush.isOpaque() && s->opacity > 0.99;

    transferMode(BrushDrawingMode);

    // updateMatrix() is responsible for setting the inverse scale on
    // the strokers, so we need to call it here and not wait for
    // prepareForDraw() down below.
    updateMatrix();

    QRectF clip = q->state()->matrix.inverted().mapRect(q->state()->clipEnabled
                                                        ? q->state()->rectangleClip
                                                        : QRectF(0, 0, width, height));

    if (penStyle == Qt::SolidLine) {
        stroker.process(path, pen, clip);

    } else { // Some sort of dash
        dasher.process(path, pen, clip);

        QVectorPath dashStroke(dasher.points(),
                               dasher.elementCount(),
                               dasher.elementTypes());
        stroker.process(dashStroke, pen, clip);
    }

    if (!stroker.vertexCount())
        return;

    if (opaque) {
        prepareForDraw(opaque);
        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, stroker.vertices());
        glDrawArrays(GL_TRIANGLE_STRIP, 0, stroker.vertexCount() / 2);

//         QBrush b(Qt::green);
//         d->setBrush(&b);
//         d->prepareForDraw(true);
//         glDrawArrays(GL_LINE_STRIP, 0, d->stroker.vertexCount() / 2);

    } else {
        qreal width = qpen_widthf(pen) / 2;
        if (width == 0)
            width = 0.5;
        qreal extra = pen.joinStyle() == Qt::MiterJoin
                      ? qMax(pen.miterLimit() * width, width)
                      : width;

        if (pen.isCosmetic())
            extra = extra * inverseScale;

        QRectF bounds = path.controlPointRect().adjusted(-extra, -extra, extra, extra);

        fillStencilWithVertexArray(stroker.vertices(), stroker.vertexCount() / 2,
                                      0, 0, bounds, QGL2PaintEngineExPrivate::TriStripStrokeFillMode);

        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);

        // Pass when any bit is set, replace stencil value with 0
        glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
        prepareForDraw(false);

        // Stencil the brush onto the dest buffer
        composite(bounds);

        glStencilMask(0);

        updateClipScissorTest();
    }
}

systemStateChanged()

void QGL2PaintEngineExPrivate::systemStateChanged ( )

virtual

Reimplemented from QPaintEnginePrivate.

Definition at line 2506 of file qpaintengineex_opengl2.cpp.

{
    Q_Q(QGL2PaintEngineEx);

    q->state()->clipChanged = true;

    if (systemClip.isEmpty()) {
        useSystemClip = false;
    } else {
        if (q->paintDevice()->devType() == QInternal::Widget && currentClipWidget) {
            QWidgetPrivate *widgetPrivate = qt_widget_private(currentClipWidget->window());
            useSystemClip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
        } else {
            useSystemClip = true;
        }
    }

    q->state()->clipTestEnabled = false;
    q->state()->needsClipBufferClear = true;

    q->state()->currentClip = 1;
    maxClip = 1;

    q->state()->rectangleClip = useSystemClip ? systemClip.boundingRect() : QRect(0, 0, width, height);
    updateClipScissorTest();

    if (systemClip.rectCount() == 1) {
        if (systemClip.boundingRect() == QRect(0, 0, width, height))
            useSystemClip = false;
#ifndef QT_GL_NO_SCISSOR_TEST
        // scissoring takes care of the system clip
        return;
#endif
    }

    if (useSystemClip) {
        clearClip(0);

        QPainterPath path;
        path.addRegion(systemClip);

        q->state()->currentClip = 0;
        writeClip(qtVectorPathForPath(q->state()->matrix.inverted().map(path)), 1);
        q->state()->currentClip = 1;
        q->state()->clipTestEnabled = true;
    }
}

transferMode()

void QGL2PaintEngineExPrivate::transferMode

(

EngineMode

newMode

)

Definition at line 650 of file qpaintengineex_opengl2.cpp.

Referenced by fill(), and QGLTextureGlyphCache::resizeTextureData().

{
    if (newMode == mode)
        return;

    if (mode == TextDrawingMode || imageDrawingMode) {
        lastTextureUsed = GLuint(-1);
    }

    if (newMode == TextDrawingMode) {
        shaderManager->setHasComplexGeometry(true);
    } else {
        shaderManager->setHasComplexGeometry(false);
    }

    imageDrawingMode = false;

    if (newMode == ImageDrawingMode) {
        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, staticTextureCoordinateArray);
        imageDrawingMode = true;
    }

    if (newMode == ImageArrayDrawingMode || newMode == ImageArrayWithOpacityDrawingMode) {
        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
        imageDrawingMode = true;
    }

    if (newMode == ImageArrayWithOpacityDrawingMode) {
        setVertexAttributePointer(QT_OPACITY_ATTR, (GLfloat*)opacityArray.data());
    }

    // This needs to change when we implement high-quality anti-aliasing...
    if (newMode != TextDrawingMode)
        shaderManager->setMaskType(QGLEngineShaderManager::NoMask);

    mode = newMode;
}

updateBrushTexture()

void QGL2PaintEngineExPrivate::updateBrushTexture

(

)

Definition at line 197 of file qpaintengineex_opengl2.cpp.

Referenced by prepareForDraw().

{
    Q_Q(QGL2PaintEngineEx);
//     qDebug("QGL2PaintEngineExPrivate::updateBrushTexture()");
    Qt::BrushStyle style = currentBrush.style();

    if ( (style >= Qt::Dense1Pattern) && (style <= Qt::DiagCrossPattern) ) {
        // Get the image data for the pattern
        QImage texImage = qt_imageForBrush(style, false);

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
        ctx->d_func()->bindTexture(texImage, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
#if !defined(QT_NO_DEBUG) && defined(QT_OPENGL_ES_2)
        QGLFunctions funcs(QGLContext::currentContext());
        bool npotSupported = funcs.hasOpenGLFeature(QGLFunctions::NPOTTextures);
        bool isNpot = !isPowerOfTwo(texImage.size().width())
            || !isPowerOfTwo(texImage.size().height());
        if (isNpot && !npotSupported) {
            qWarning("GL2 Paint Engine: This system does not support the REPEAT wrap mode for non-power-of-two textures.");
        }
#endif
        updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
    }
    else if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
        // Gradiant brush: All the gradiants use the same texture

        const QGradient* g = currentBrush.gradient();

        // We apply global opacity in the fragment shaders, so we always pass 1.0
        // for opacity to the cache.
        GLuint texId = QGL2GradientCache::cacheForContext(ctx)->getBuffer(*g, 1.0);

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
        glBindTexture(GL_TEXTURE_2D, texId);

        if (g->spread() == QGradient::RepeatSpread || g->type() == QGradient::ConicalGradient)
            updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
        else if (g->spread() == QGradient::ReflectSpread)
            updateTextureFilter(GL_TEXTURE_2D, GL_MIRRORED_REPEAT_IBM, q->state()->renderHints & QPainter::SmoothPixmapTransform);
        else
            updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE, q->state()->renderHints & QPainter::SmoothPixmapTransform);
    }
    else if (style == Qt::TexturePattern) {
        currentBrushPixmap = currentBrush.texture();

        int max_texture_size = ctx->d_func()->maxTextureSize();
        if (currentBrushPixmap.width() > max_texture_size || currentBrushPixmap.height() > max_texture_size)
            currentBrushPixmap = currentBrushPixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
        QGLTexture *tex = ctx->d_func()->bindTexture(currentBrushPixmap, GL_TEXTURE_2D, GL_RGBA,
                                                     QGLContext::InternalBindOption |
                                                     QGLContext::CanFlipNativePixmapBindOption);
        GLenum wrapMode = GL_REPEAT;
#ifdef QT_OPENGL_ES_2
        // should check for GL_OES_texture_npot or GL_IMG_texture_npot extension
        if (!isPowerOfTwo(currentBrushPixmap.width()) || !isPowerOfTwo(currentBrushPixmap.height()))
            wrapMode = GL_CLAMP_TO_EDGE;
#endif
        updateTextureFilter(GL_TEXTURE_2D, wrapMode, q->state()->renderHints & QPainter::SmoothPixmapTransform);
        textureInvertedY = tex->options & QGLContext::InvertedYBindOption ? -1 : 1;
    }
    brushTextureDirty = false;
}

updateBrushUniforms()

void QGL2PaintEngineExPrivate::updateBrushUniforms

(

)

Definition at line 263 of file qpaintengineex_opengl2.cpp.

Referenced by prepareForDraw().

{
//     qDebug("QGL2PaintEngineExPrivate::updateBrushUniforms()");
    Qt::BrushStyle style = currentBrush.style();

    if (style == Qt::NoBrush)
        return;

    QTransform brushQTransform = currentBrush.transform();

    if (style == Qt::SolidPattern) {
        QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::FragmentColor), col);
    }
    else {
        // All other brushes have a transform and thus need the translation point:
        QPointF translationPoint;

        if (style <= Qt::DiagCrossPattern) {
            QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);

            QVector2D halfViewportSize(width*0.5, height*0.5);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
        }
        else if (style == Qt::LinearGradientPattern) {
            const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush.gradient());

            QPointF realStart = g->start();
            QPointF realFinal = g->finalStop();
            translationPoint = realStart;

            QPointF l = realFinal - realStart;

            QVector3D linearData(
                l.x(),
                l.y(),
                1.0f / (l.x() * l.x() + l.y() * l.y())
            );

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::LinearData), linearData);

            QVector2D halfViewportSize(width*0.5, height*0.5);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
        }
        else if (style == Qt::ConicalGradientPattern) {
            const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush.gradient());
            translationPoint   = g->center();

            GLfloat angle = -(g->angle() * 2 * Q_PI) / 360.0;

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Angle), angle);

            QVector2D halfViewportSize(width*0.5, height*0.5);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
        }
        else if (style == Qt::RadialGradientPattern) {
            const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush.gradient());
            QPointF realCenter = g->center();
            QPointF realFocal  = g->focalPoint();
            qreal   realRadius = g->centerRadius() - g->focalRadius();
            translationPoint   = realFocal;

            QPointF fmp = realCenter - realFocal;
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp), fmp);

            GLfloat fmp2_m_radius2 = -fmp.x() * fmp.x() - fmp.y() * fmp.y() + realRadius*realRadius;
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Inverse2Fmp2MRadius2),
                                                             GLfloat(1.0 / (2.0*fmp2_m_radius2)));
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::SqrFr),
                                                             GLfloat(g->focalRadius() * g->focalRadius()));
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BRadius),
                                                             GLfloat(2 * (g->centerRadius() - g->focalRadius()) * g->focalRadius()),
                                                             g->focalRadius(),
                                                             g->centerRadius() - g->focalRadius());

            QVector2D halfViewportSize(width*0.5, height*0.5);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
        }
        else if (style == Qt::TexturePattern) {
            const QPixmap& texPixmap = currentBrush.texture();

            if (qHasPixmapTexture(currentBrush) && currentBrush.texture().isQBitmap()) {
                QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
                shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
            }

            QSizeF invertedTextureSize(1.0 / texPixmap.width(), 1.0 / texPixmap.height());
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::InvertedTextureSize), invertedTextureSize);

            QVector2D halfViewportSize(width*0.5, height*0.5);
            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
        }
        else
            qWarning("QGL2PaintEngineEx: Unimplemented fill style");

        const QPointF &brushOrigin = q->state()->brushOrigin;
        QTransform matrix = q->state()->matrix;
        matrix.translate(brushOrigin.x(), brushOrigin.y());

        QTransform translate(1, 0, 0, 1, -translationPoint.x(), -translationPoint.y());
        qreal m22 = -1;
        qreal dy = height;
        if (device->isFlipped()) {
            m22 = 1;
            dy = 0;
        }
        QTransform gl_to_qt(1, 0, 0, m22, 0, dy);
        QTransform inv_matrix;
        if (style == Qt::TexturePattern && textureInvertedY == -1)
            inv_matrix = gl_to_qt * (QTransform(1, 0, 0, -1, 0, currentBrush.texture().height()) * brushQTransform * matrix).inverted() * translate;
        else
            inv_matrix = gl_to_qt * (brushQTransform * matrix).inverted() * translate;

        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTransform), inv_matrix);
        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTexture), QT_BRUSH_TEXTURE_UNIT);
    }
    brushUniformsDirty = false;
}

updateClipScissorTest()

void QGL2PaintEngineExPrivate::updateClipScissorTest

(

)

Definition at line 2252 of file qpaintengineex_opengl2.cpp.

Referenced by fill(), fillStencilWithVertexArray(), and QGLTextureGlyphCache::resizeTextureData().

{
    Q_Q(QGL2PaintEngineEx);
    if (q->state()->clipTestEnabled) {
        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
    } else {
        glDisable(GL_STENCIL_TEST);
        glStencilFunc(GL_ALWAYS, 0, 0xff);
    }

#ifdef QT_GL_NO_SCISSOR_TEST
    currentScissorBounds = QRect(0, 0, width, height);
#else
    QRect bounds = q->state()->rectangleClip;
    if (!q->state()->clipEnabled) {
        if (useSystemClip)
            bounds = systemClip.boundingRect();
        else
            bounds = QRect(0, 0, width, height);
    } else {
        if (useSystemClip)
            bounds = bounds.intersected(systemClip.boundingRect());
        else
            bounds = bounds.intersected(QRect(0, 0, width, height));
    }

    currentScissorBounds = bounds;

    if (bounds == QRect(0, 0, width, height)) {
        if (ctx->d_func()->workaround_brokenScissor)
            clearClip(0);
        glDisable(GL_SCISSOR_TEST);
    } else {
        glEnable(GL_SCISSOR_TEST);
        setScissor(bounds);
    }
#endif
}

updateCompositionMode()

void QGL2PaintEngineExPrivate::updateCompositionMode

(

)

Definition at line 458 of file qpaintengineex_opengl2.cpp.

Referenced by prepareForDraw().

{
    // NOTE: The entire paint engine works on pre-multiplied data - which is why some of these
    //       composition modes look odd.
//     qDebug() << "QGL2PaintEngineExPrivate::updateCompositionMode() - Setting GL composition mode for " << q->state()->composition_mode;
    switch(q->state()->composition_mode) {
    case QPainter::CompositionMode_SourceOver:
        glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_DestinationOver:
        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
        break;
    case QPainter::CompositionMode_Clear:
        glBlendFunc(GL_ZERO, GL_ZERO);
        break;
    case QPainter::CompositionMode_Source:
        glBlendFunc(GL_ONE, GL_ZERO);
        break;
    case QPainter::CompositionMode_Destination:
        glBlendFunc(GL_ZERO, GL_ONE);
        break;
    case QPainter::CompositionMode_SourceIn:
        glBlendFunc(GL_DST_ALPHA, GL_ZERO);
        break;
    case QPainter::CompositionMode_DestinationIn:
        glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_SourceOut:
        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
        break;
    case QPainter::CompositionMode_DestinationOut:
        glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_SourceAtop:
        glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_DestinationAtop:
        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_Xor:
        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        break;
    case QPainter::CompositionMode_Plus:
        glBlendFunc(GL_ONE, GL_ONE);
        break;
    default:
        qWarning("Unsupported composition mode");
        break;
    }

    compositionModeDirty = false;
}

updateMatrix()

void QGL2PaintEngineExPrivate::updateMatrix

(

)

Definition at line 387 of file qpaintengineex_opengl2.cpp.

Referenced by fill(), prepareForDraw(), and useSimpleShader().

{
//     qDebug("QGL2PaintEngineExPrivate::updateMatrix()");

    const QTransform& transform = q->state()->matrix;

    // The projection matrix converts from Qt's coordinate system to GL's coordinate system
    //    * GL's viewport is 2x2, Qt's is width x height
    //    * GL has +y -> -y going from bottom -> top, Qt is the other way round
    //    * GL has [0,0] in the center, Qt has it in the top-left
    //
    // This results in the Projection matrix below, which is multiplied by the painter's
    // transformation matrix, as shown below:
    //
    //                Projection Matrix                      Painter Transform
    // ------------------------------------------------   ------------------------
    // | 2.0 / width  |      0.0      |     -1.0      |   |  m11  |  m21  |  dx  |
    // |     0.0      | -2.0 / height |      1.0      | * |  m12  |  m22  |  dy  |
    // |     0.0      |      0.0      |      1.0      |   |  m13  |  m23  |  m33 |
    // ------------------------------------------------   ------------------------
    //
    // NOTE: The resultant matrix is also transposed, as GL expects column-major matracies

    const GLfloat wfactor = 2.0f / width;
    GLfloat hfactor = -2.0f / height;

    GLfloat dx = transform.dx();
    GLfloat dy = transform.dy();

    if (device->isFlipped()) {
        hfactor *= -1;
        dy -= height;
    }

    // Non-integer translates can have strange effects for some rendering operations such as
    // anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.
    if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {
        // 0.50 needs to rounded down to 0.0 for consistency with raster engine:
        dx = ceilf(dx - 0.5f);
        dy = ceilf(dy - 0.5f);
    }
    pmvMatrix[0][0] = (wfactor * transform.m11())  - transform.m13();
    pmvMatrix[1][0] = (wfactor * transform.m21())  - transform.m23();
    pmvMatrix[2][0] = (wfactor * dx) - transform.m33();
    pmvMatrix[0][1] = (hfactor * transform.m12())  + transform.m13();
    pmvMatrix[1][1] = (hfactor * transform.m22())  + transform.m23();
    pmvMatrix[2][1] = (hfactor * dy) + transform.m33();
    pmvMatrix[0][2] = transform.m13();
    pmvMatrix[1][2] = transform.m23();
    pmvMatrix[2][2] = transform.m33();

    // 1/10000 == 0.0001, so we have good enough res to cover curves
    // that span the entire widget...
    inverseScale = qMax(1 / qMax( qMax(qAbs(transform.m11()), qAbs(transform.m22())),
                                  qMax(qAbs(transform.m12()), qAbs(transform.m21())) ),
                        qreal(0.0001));

    matrixDirty = false;
    matrixUniformDirty = true;

    // Set the PMV matrix attribute. As we use an attributes rather than uniforms, we only
    // need to do this once for every matrix change and persists across all shader programs.
    glVertexAttrib3fv(QT_PMV_MATRIX_1_ATTR, pmvMatrix[0]);
    glVertexAttrib3fv(QT_PMV_MATRIX_2_ATTR, pmvMatrix[1]);
    glVertexAttrib3fv(QT_PMV_MATRIX_3_ATTR, pmvMatrix[2]);

    dasher.setInvScale(inverseScale);
    stroker.setInvScale(inverseScale);
}

updateTextureFilter()

void QGL2PaintEngineExPrivate::updateTextureFilter	(	GLenum	target,
		GLenum	wrapMode,
		bool	smoothPixmapTransform,
		GLuint	id = -1
	)

Definition at line 131 of file qpaintengineex_opengl2.cpp.

Referenced by updateBrushTexture().

{
//    glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT); //### Is it always this texture unit?
    if (id != GLuint(-1) && id == lastTextureUsed)
        return;

    lastTextureUsed = id;

    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);
}

useSimpleShader()

void QGL2PaintEngineExPrivate::useSimpleShader ( )

inline

Definition at line 189 of file qpaintengineex_opengl2.cpp.

Referenced by fillStencilWithVertexArray(), and resetClipIfNeeded().

{
    shaderManager->useSimpleProgram();

    if (matrixDirty)
        updateMatrix();
}

writeClip()

void QGL2PaintEngineExPrivate::writeClip	(	const QVectorPath &	path,
		uint	value
	)

Definition at line 2329 of file qpaintengineex_opengl2.cpp.

{
    transferMode(BrushDrawingMode);

    if (snapToPixelGrid) {
        snapToPixelGrid = false;
        matrixDirty = true;
    }

    if (matrixDirty)
        updateMatrix();

    stencilClean = false;

    const bool singlePass = !path.hasWindingFill()
        && (((q->state()->currentClip == maxClip - 1) && q->state()->clipTestEnabled)
            || q->state()->needsClipBufferClear);
    const uint referenceClipValue = q->state()->needsClipBufferClear ? 1 : q->state()->currentClip;

    if (q->state()->needsClipBufferClear)
        clearClip(1);

    if (path.isEmpty()) {
        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
        return;
    }

    if (q->state()->clipTestEnabled)
        glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
    else
        glStencilFunc(GL_ALWAYS, 0, 0xff);

    vertexCoordinateArray.clear();
    vertexCoordinateArray.addPath(path, inverseScale, false);

    if (!singlePass)
        fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());

    glColorMask(false, false, false, false);
    glEnable(GL_STENCIL_TEST);
    useSimpleShader();

    if (singlePass) {
        // Under these conditions we can set the new stencil value in a single
        // pass, by using the current value and the "new value" as the toggles

        glStencilFunc(GL_LEQUAL, referenceClipValue, ~GL_STENCIL_HIGH_BIT);
        glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
        glStencilMask(value ^ referenceClipValue);

        drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
    } else {
        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
        glStencilMask(0xff);

        if (!q->state()->clipTestEnabled && path.hasWindingFill()) {
            // Pass when any clip bit is set, set high bit
            glStencilFunc(GL_NOTEQUAL, GL_STENCIL_HIGH_BIT, ~GL_STENCIL_HIGH_BIT);
            composite(vertexCoordinateArray.boundingRect());
        }

        // Pass when high bit is set, replace stencil value with new clip value
        glStencilFunc(GL_NOTEQUAL, value, GL_STENCIL_HIGH_BIT);

        composite(vertexCoordinateArray.boundingRect());
    }

    glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
    glStencilMask(0);

    glColorMask(true, true, true, true);
}

Properties

blurFilter

QScopedPointer<QPixmapFilter> QGL2PaintEngineExPrivate::blurFilter

Definition at line 314 of file qpaintengineex_opengl2_p.h.

brushTextureDirty

bool QGL2PaintEngineExPrivate::brushTextureDirty

Definition at line 270 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), setBrush(), and updateBrushTexture().

brushUniformsDirty

bool QGL2PaintEngineExPrivate::brushUniformsDirty

Definition at line 271 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), setBrush(), and updateBrushUniforms().

colorizeFilter

QScopedPointer<QPixmapFilter> QGL2PaintEngineExPrivate::colorizeFilter

Definition at line 313 of file qpaintengineex_opengl2_p.h.

compositionModeDirty

bool QGL2PaintEngineExPrivate::compositionModeDirty

Definition at line 269 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), and updateCompositionMode().

convolutionFilter

QScopedPointer<QPixmapFilter> QGL2PaintEngineExPrivate::convolutionFilter

Definition at line 312 of file qpaintengineex_opengl2_p.h.

ctx

QGLContext* QGL2PaintEngineExPrivate::ctx

Definition at line 262 of file qpaintengineex_opengl2_p.h.

Referenced by QGL2PaintEngineEx::beginNativePainting(), resetGLState(), and updateBrushTexture().

currentBrush

QBrush QGL2PaintEngineExPrivate::currentBrush

Definition at line 281 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), fill(), prepareForDraw(), setBrush(), updateBrushTexture(), and updateBrushUniforms().

currentBrushPixmap

QPixmap QGL2PaintEngineExPrivate::currentBrushPixmap

Definition at line 284 of file qpaintengineex_opengl2_p.h.

Referenced by setBrush(), and updateBrushTexture().

currentScissorBounds

QRect QGL2PaintEngineExPrivate::currentScissorBounds

Definition at line 278 of file qpaintengineex_opengl2_p.h.

Referenced by fillStencilWithVertexArray().

dasher

QDashedStrokeProcessor QGL2PaintEngineExPrivate::dasher

Definition at line 310 of file qpaintengineex_opengl2_p.h.

Referenced by updateMatrix().

depthRange

GLfloat QGL2PaintEngineExPrivate::depthRange[2]

Definition at line 305 of file qpaintengineex_opengl2_p.h.

device

QGLPaintDevice* QGL2PaintEngineExPrivate::device

Definition at line 260 of file qpaintengineex_opengl2_p.h.

Referenced by fill(), updateBrushUniforms(), and updateMatrix().

dirtyStencilRegion

QRegion QGL2PaintEngineExPrivate::dirtyStencilRegion

Definition at line 277 of file qpaintengineex_opengl2_p.h.

Referenced by fillStencilWithVertexArray().

dropShadowFilter

QScopedPointer<QPixmapFilter> QGL2PaintEngineExPrivate::dropShadowFilter

Definition at line 315 of file qpaintengineex_opengl2_p.h.

elementIndices

QVector<GLushort> QGL2PaintEngineExPrivate::elementIndices

Definition at line 288 of file qpaintengineex_opengl2_p.h.

elementIndicesVBOId

GLuint QGL2PaintEngineExPrivate::elementIndicesVBOId

Definition at line 289 of file qpaintengineex_opengl2_p.h.

Referenced by ~QGL2PaintEngineExPrivate().

glyphCacheType

QFontEngineGlyphCache::Type QGL2PaintEngineExPrivate::glyphCacheType

Definition at line 265 of file qpaintengineex_opengl2_p.h.

hasCompatibilityExtension

bool QGL2PaintEngineExPrivate::hasCompatibilityExtension

Definition at line 323 of file qpaintengineex_opengl2_p.h.

height

int QGL2PaintEngineExPrivate::height

Definition at line 261 of file qpaintengineex_opengl2_p.h.

Referenced by resetClipIfNeeded(), QGLTextureGlyphCache::resizeTextureData(), updateBrushUniforms(), and updateMatrix().

imageDrawingMode

bool QGL2PaintEngineExPrivate::imageDrawingMode

Definition at line 264 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), and transferMode().

inverseScale

GLfloat QGL2PaintEngineExPrivate::inverseScale

Definition at line 297 of file qpaintengineex_opengl2_p.h.

Referenced by fill(), and updateMatrix().

lastMaskTextureUsed

GLuint QGL2PaintEngineExPrivate::lastMaskTextureUsed

Definition at line 300 of file qpaintengineex_opengl2_p.h.

lastTextureUsed

GLuint QGL2PaintEngineExPrivate::lastTextureUsed

Definition at line 299 of file qpaintengineex_opengl2_p.h.

Referenced by transferMode(), and updateTextureFilter().

matrixDirty

bool QGL2PaintEngineExPrivate::matrixDirty

Definition at line 268 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), fill(), prepareForDraw(), updateMatrix(), and useSimpleShader().

matrixUniformDirty

bool QGL2PaintEngineExPrivate::matrixUniformDirty

Definition at line 273 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), and updateMatrix().

maxClip

uint QGL2PaintEngineExPrivate::maxClip

Definition at line 279 of file qpaintengineex_opengl2_p.h.

Referenced by resetClipIfNeeded().

mode

EngineMode QGL2PaintEngineExPrivate::mode

Definition at line 263 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), and transferMode().

multisamplingAlwaysEnabled

bool QGL2PaintEngineExPrivate::multisamplingAlwaysEnabled

Definition at line 303 of file qpaintengineex_opengl2_p.h.

nativePaintingActive

bool QGL2PaintEngineExPrivate::nativePaintingActive

Definition at line 295 of file qpaintengineex_opengl2_p.h.

needsSync

bool QGL2PaintEngineExPrivate::needsSync

Definition at line 302 of file qpaintengineex_opengl2_p.h.

noBrush

const QBrush QGL2PaintEngineExPrivate::noBrush

Definition at line 282 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture().

opacityArray

QDataBuffer<GLfloat> QGL2PaintEngineExPrivate::opacityArray

Definition at line 290 of file qpaintengineex_opengl2_p.h.

Referenced by transferMode().

opacityUniformDirty

bool QGL2PaintEngineExPrivate::opacityUniformDirty

Definition at line 272 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw().

pathCaches

QSet<QVectorPath::CacheEntry *> QGL2PaintEngineExPrivate::pathCaches

Definition at line 317 of file qpaintengineex_opengl2_p.h.

Referenced by ~QGL2PaintEngineExPrivate().

pmvMatrix

GLfloat QGL2PaintEngineExPrivate::pmvMatrix[3][3]

Definition at line 296 of file qpaintengineex_opengl2_p.h.

Referenced by prepareForDraw(), and updateMatrix().

q

QGL2PaintEngineEx* QGL2PaintEngineExPrivate::q

Definition at line 258 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), fill(), fillStencilWithVertexArray(), prepareForDraw(), resetClipIfNeeded(), updateBrushTexture(), updateBrushUniforms(), updateCompositionMode(), and updateMatrix().

shaderManager

QGLEngineShaderManager* QGL2PaintEngineExPrivate::shaderManager

Definition at line 259 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), prepareForDraw(), QGLTextureGlyphCache::resizeTextureData(), setBrush(), transferMode(), updateBrushUniforms(), useSimpleShader(), and ~QGL2PaintEngineExPrivate().

snapToPixelGrid

bool QGL2PaintEngineExPrivate::snapToPixelGrid

Definition at line 294 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), fill(), and updateMatrix().

staticTextureCoordinateArray

GLfloat QGL2PaintEngineExPrivate::staticTextureCoordinateArray[8]

Definition at line 292 of file qpaintengineex_opengl2_p.h.

Referenced by drawTexture(), and transferMode().

staticVertexCoordinateArray

GLfloat QGL2PaintEngineExPrivate::staticVertexCoordinateArray[8]

Definition at line 291 of file qpaintengineex_opengl2_p.h.

Referenced by composite(), drawTexture(), and transferMode().

stencilClean

bool QGL2PaintEngineExPrivate::stencilClean

Definition at line 275 of file qpaintengineex_opengl2_p.h.

Referenced by fillStencilWithVertexArray().

stroker

QTriangulatingStroker QGL2PaintEngineExPrivate::stroker

Definition at line 309 of file qpaintengineex_opengl2_p.h.

Referenced by updateMatrix().

textureCoordinateArray

QGL2PEXVertexArray QGL2PaintEngineExPrivate::textureCoordinateArray

Definition at line 287 of file qpaintengineex_opengl2_p.h.

Referenced by transferMode().

textureInvertedY

float QGL2PaintEngineExPrivate::textureInvertedY

Definition at line 307 of file qpaintengineex_opengl2_p.h.

Referenced by updateBrushTexture(), and updateBrushUniforms().

unusedIBOSToClean

QVector<GLuint> QGL2PaintEngineExPrivate::unusedIBOSToClean

Definition at line 319 of file qpaintengineex_opengl2_p.h.

unusedVBOSToClean

QVector<GLuint> QGL2PaintEngineExPrivate::unusedVBOSToClean

Definition at line 318 of file qpaintengineex_opengl2_p.h.

useSystemClip

bool QGL2PaintEngineExPrivate::useSystemClip

Definition at line 276 of file qpaintengineex_opengl2_p.h.

vertexAttribPointers

const GLfloat* QGL2PaintEngineExPrivate::vertexAttribPointers[3]

Definition at line 321 of file qpaintengineex_opengl2_p.h.

vertexCoordinateArray

QGL2PEXVertexArray QGL2PaintEngineExPrivate::vertexCoordinateArray

Definition at line 286 of file qpaintengineex_opengl2_p.h.

Referenced by fill(), and transferMode().

width

int QGL2PaintEngineExPrivate::width

Definition at line 261 of file qpaintengineex_opengl2_p.h.

Referenced by resetClipIfNeeded(), QGLTextureGlyphCache::resizeTextureData(), updateBrushUniforms(), and updateMatrix().

---

The documentation for this class was generated from the following files:

• /src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
• /src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp