diff options
4 files changed, 168 insertions, 49 deletions
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp index ac89599..4b73ca9 100644 --- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp +++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp @@ -191,7 +191,29 @@ QGLEngineShaderManager::~QGLEngineShaderManager() } +uint QGLEngineShaderManager::getUniformIdentifier(const char *uniformName) +{ + uniformIdentifiers << uniformName; + return uniformIdentifiers.size() - 1; +} + +uint QGLEngineShaderManager::getUniformLocation(uint id) +{ + QVector<uint> &uniformLocations = currentShaderProg->uniformLocations; + uint oldSize = uniformLocations.size(); + if (oldSize <= id) { + uint newSize = id + 1; + uniformLocations.resize(newSize); + + for (uint i = oldSize; i < newSize; ++i) + uniformLocations[i] = GLuint(-1); + } + if (uniformLocations.at(id) == GLuint(-1)) + uniformLocations[id] = currentShaderProg->program->uniformLocation(uniformIdentifiers.at(id)); + + return uniformLocations.at(id); +} void QGLEngineShaderManager::optimiseForBrushTransform(const QTransform &transform) @@ -206,43 +228,61 @@ void QGLEngineShaderManager::setDirty() void QGLEngineShaderManager::setSrcPixelType(Qt::BrushStyle style) { + if (srcPixelType == PixelSrcType(style)) + return; + srcPixelType = style; shaderProgNeedsChanging = true; //### } void QGLEngineShaderManager::setSrcPixelType(PixelSrcType type) { + if (srcPixelType == type) + return; + srcPixelType = type; shaderProgNeedsChanging = true; //### } void QGLEngineShaderManager::setTextureCoordsEnabled(bool enabled) { + if (useTextureCoords == enabled) + return; + useTextureCoords = enabled; shaderProgNeedsChanging = true; //### } void QGLEngineShaderManager::setUseGlobalOpacity(bool useOpacity) { + if (useGlobalOpacity == useOpacity) + return; + useGlobalOpacity = useOpacity; shaderProgNeedsChanging = true; //### } void QGLEngineShaderManager::setMaskType(MaskType type) { + if (maskType == type) + return; + maskType = type; shaderProgNeedsChanging = true; //### } void QGLEngineShaderManager::setCompositionMode(QPainter::CompositionMode mode) { + if (compositionMode == mode) + return; + compositionMode = mode; shaderProgNeedsChanging = true; //### } QGLShaderProgram* QGLEngineShaderManager::currentProgram() { - return currentShaderProg; + return currentShaderProg->program; } QGLShaderProgram* QGLEngineShaderManager::simpleProgram() @@ -432,15 +472,16 @@ bool QGLEngineShaderManager::useCorrectShaderProg() // At this point, requiredProgram is fully populated so try to find the program in the cache - foreach (const QGLEngineShaderProg &prog, cachedPrograms) { + for (int i = 0; i < cachedPrograms.size(); ++i) { + QGLEngineShaderProg &prog = cachedPrograms[i]; if ( (prog.mainVertexShader == requiredProgram.mainVertexShader) && (prog.positionVertexShader == requiredProgram.positionVertexShader) && (prog.mainFragShader == requiredProgram.mainFragShader) && (prog.srcPixelFragShader == requiredProgram.srcPixelFragShader) && (prog.compositionFragShader == requiredProgram.compositionFragShader) ) { - currentShaderProg = prog.program; - currentShaderProg->enable(); + currentShaderProg = &prog; + currentShaderProg->program->enable(); shaderProgNeedsChanging = false; return true; } @@ -480,8 +521,10 @@ bool QGLEngineShaderManager::useCorrectShaderProg() } else { cachedPrograms.append(requiredProgram); - currentShaderProg = requiredProgram.program; - currentShaderProg->enable(); + // taking the address here is safe since + // cachePrograms isn't resized anywhere else + currentShaderProg = &cachedPrograms.last(); + currentShaderProg->program->enable(); } shaderProgNeedsChanging = false; return true; diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h index 9013884..34f0768 100644 --- a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h +++ b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h @@ -237,6 +237,8 @@ struct QGLEngineShaderProg QGLShader* maskFragShader; // Can be null for no mask QGLShader* compositionFragShader; // Can be null for GL-handled mode QGLShaderProgram* program; + + QVector<uint> uniformLocations; }; /* @@ -283,6 +285,9 @@ public: void setMaskType(MaskType); void setCompositionMode(QPainter::CompositionMode); + uint getUniformIdentifier(const char *uniformName); + uint getUniformLocation(uint id); + void setDirty(); // someone has manually changed the current shader program bool useCorrectShaderProg(); // returns true if the shader program needed to be changed @@ -374,9 +379,9 @@ private: bool useTextureCoords; QPainter::CompositionMode compositionMode; - QGLShaderProgram* blitShaderProg; - QGLShaderProgram* simpleShaderProg; - QGLShaderProgram* currentShaderProg; + QGLShaderProgram* blitShaderProg; + QGLShaderProgram* simpleShaderProg; + QGLEngineShaderProg* currentShaderProg; // TODO: Possibly convert to a LUT QList<QGLEngineShaderProg> cachedPrograms; @@ -386,6 +391,8 @@ private: void compileNamedShader(QGLEngineShaderManager::ShaderName name, QGLShader::ShaderType type); static const char* qglEngineShaderSourceCode[TotalShaderCount]; + + QVector<const char *> uniformIdentifiers; }; QT_END_NAMESPACE diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp index 6ff0c53..91df197 100644 --- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp @@ -248,9 +248,13 @@ QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate() } } -void QGL2PaintEngineExPrivate::updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform) +void QGL2PaintEngineExPrivate::updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id) { // glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT); //### Is it always this texture unit? + if (id != -1 && id == lastTexture) + return; + + lastTexture = id; if (smoothPixmapTransform) { glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); @@ -368,7 +372,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() if (style == Qt::SolidPattern) { QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); - shaderManager->currentProgram()->setUniformValue("fragmentColor", col); + shaderManager->currentProgram()->setUniformValue(location(FragmentColor), col); } else { // All other brushes have a transform and thus need the translation point: @@ -379,10 +383,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); - shaderManager->currentProgram()->setUniformValue("patternColor", col); + shaderManager->currentProgram()->setUniformValue(location(PatternColor), col); QVector2D halfViewportSize(width*0.5, height*0.5); - shaderManager->currentProgram()->setUniformValue("halfViewportSize", halfViewportSize); + shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize); } else if (style == Qt::LinearGradientPattern) { const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush->gradient()); @@ -399,10 +403,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() 1.0f / (l.x() * l.x() + l.y() * l.y()) ); - shaderManager->currentProgram()->setUniformValue("linearData", linearData); + shaderManager->currentProgram()->setUniformValue(location(LinearData), linearData); QVector2D halfViewportSize(width*0.5, height*0.5); - shaderManager->currentProgram()->setUniformValue("halfViewportSize", halfViewportSize); + shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize); } else if (style == Qt::ConicalGradientPattern) { const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush->gradient()); @@ -410,10 +414,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() GLfloat angle = -(g->angle() * 2 * Q_PI) / 360.0; - shaderManager->currentProgram()->setUniformValue("angle", angle); + shaderManager->currentProgram()->setUniformValue(location(Angle), angle); QVector2D halfViewportSize(width*0.5, height*0.5); - shaderManager->currentProgram()->setUniformValue("halfViewportSize", halfViewportSize); + shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize); } else if (style == Qt::RadialGradientPattern) { const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush->gradient()); @@ -423,15 +427,15 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() translationPoint = realFocal; QPointF fmp = realCenter - realFocal; - shaderManager->currentProgram()->setUniformValue("fmp", fmp); + shaderManager->currentProgram()->setUniformValue(location(Fmp), fmp); GLfloat fmp2_m_radius2 = -fmp.x() * fmp.x() - fmp.y() * fmp.y() + realRadius*realRadius; - shaderManager->currentProgram()->setUniformValue("fmp2_m_radius2", fmp2_m_radius2); - shaderManager->currentProgram()->setUniformValue("inverse_2_fmp2_m_radius2", + shaderManager->currentProgram()->setUniformValue(location(Fmp2MRadius2), fmp2_m_radius2); + shaderManager->currentProgram()->setUniformValue(location(Inverse2Fmp2MRadius2), GLfloat(1.0 / (2.0*fmp2_m_radius2))); QVector2D halfViewportSize(width*0.5, height*0.5); - shaderManager->currentProgram()->setUniformValue("halfViewportSize", halfViewportSize); + shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize); } else if (style == Qt::TexturePattern) { translationPoint = q->state()->brushOrigin; @@ -440,14 +444,14 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() if (qHasPixmapTexture(*currentBrush) && currentBrush->texture().isQBitmap()) { QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); - shaderManager->currentProgram()->setUniformValue("patternColor", col); + shaderManager->currentProgram()->setUniformValue(location(PatternColor), col); } QSizeF invertedTextureSize( 1.0 / texPixmap.width(), 1.0 / texPixmap.height() ); - shaderManager->currentProgram()->setUniformValue("invertedTextureSize", invertedTextureSize); + shaderManager->currentProgram()->setUniformValue(location(InvertedTextureSize), invertedTextureSize); QVector2D halfViewportSize(width*0.5, height*0.5); - shaderManager->currentProgram()->setUniformValue("halfViewportSize", halfViewportSize); + shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize); } else qWarning("QGL2PaintEngineEx: Unimplemented fill style"); @@ -456,8 +460,8 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() QTransform gl_to_qt(1, 0, 0, -1, 0, height); QTransform inv_matrix = gl_to_qt * (brushQTransform * q->state()->matrix).inverted() * translate; - shaderManager->currentProgram()->setUniformValue("brushTransform", inv_matrix); - shaderManager->currentProgram()->setUniformValue("brushTexture", QT_BRUSH_TEXTURE_UNIT); + shaderManager->currentProgram()->setUniformValue(location(BrushTransform), inv_matrix); + shaderManager->currentProgram()->setUniformValue(location(BrushTexture), QT_BRUSH_TEXTURE_UNIT); } brushUniformsDirty = false; } @@ -591,22 +595,17 @@ static inline void setCoords(GLfloat *coords, const QGLRect &rect) void QGL2PaintEngineExPrivate::drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern) { - transferMode(ImageDrawingMode); - - updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform); - // Setup for texture drawing shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc); shaderManager->setTextureCoordsEnabled(true); - prepareForDraw(opaque); + if (prepareForDraw(opaque)) + shaderManager->currentProgram()->setUniformValue(location(ImageTexture), QT_IMAGE_TEXTURE_UNIT); if (pattern) { QColor col = premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity); - shaderManager->currentProgram()->setUniformValue("patternColor", col); + shaderManager->currentProgram()->setUniformValue(location(PatternColor), col); } - shaderManager->currentProgram()->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT); - GLfloat dx = 1.0 / textureSize.width(); GLfloat dy = 1.0 / textureSize.height(); @@ -651,6 +650,8 @@ void QGL2PaintEngineEx::sync() glLoadMatrixf(&mv_matrix[0][0]); #endif + d->lastTexture = GLuint(-1); + glDisable(GL_BLEND); glActiveTexture(GL_TEXTURE0); } @@ -663,6 +664,8 @@ void QGL2PaintEngineExPrivate::transferMode(EngineMode newMode) if (mode == TextDrawingMode || mode == ImageDrawingMode) { glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR); glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR); + + lastTexture = GLuint(-1); } if (mode == TextDrawingMode) @@ -796,7 +799,7 @@ void QGL2PaintEngineExPrivate::fillStencilWithVertexArray(QGL2PEXVertexArray& ve glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } -void QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque) +bool QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque) { if (brushTextureDirty && mode != ImageDrawingMode) updateBrushTexture(); @@ -808,12 +811,14 @@ void QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque) updateMatrix(); const bool stateHasOpacity = q->state()->opacity < 0.99f; - if (q->state()->compositionMode() == QPainter::CompositionMode_Source - || (q->state()->compositionMode() == QPainter::CompositionMode_SourceOver + if (q->state()->composition_mode == QPainter::CompositionMode_Source + || (q->state()->composition_mode == QPainter::CompositionMode_SourceOver && srcPixelsAreOpaque && !stateHasOpacity)) + { glDisable(GL_BLEND); - else + } else { glEnable(GL_BLEND); + } bool useGlobalOpacityUniform = stateHasOpacity; if (stateHasOpacity && (mode != ImageDrawingMode)) { @@ -827,29 +832,35 @@ void QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque) shaderManager->setUseGlobalOpacity(useGlobalOpacityUniform); + bool changed = shaderManager->useCorrectShaderProg(); // If the shader program needs changing, we change it and mark all uniforms as dirty - if (shaderManager->useCorrectShaderProg()) { + if (changed) { // The shader program has changed so mark all uniforms as dirty: brushUniformsDirty = true; shaderMatrixUniformDirty = true; depthUniformDirty = true; + opacityUniformDirty = true; } if (brushUniformsDirty && mode != ImageDrawingMode) updateBrushUniforms(); if (shaderMatrixUniformDirty) { - shaderManager->currentProgram()->setUniformValue("pmvMatrix", pmvMatrix); + shaderManager->currentProgram()->setUniformValue(location(PmvMatrix), pmvMatrix); shaderMatrixUniformDirty = false; } if (depthUniformDirty) { - shaderManager->currentProgram()->setUniformValue("depth", (GLfloat)q->state()->currentDepth); + shaderManager->currentProgram()->setUniformValue(location(Depth), (GLfloat)q->state()->currentDepth); depthUniformDirty = false; } - if (useGlobalOpacityUniform) - shaderManager->currentProgram()->setUniformValue("globalOpacity", (GLfloat)q->state()->opacity); + if (useGlobalOpacityUniform && opacityUniformDirty) { + shaderManager->currentProgram()->setUniformValue(location(GlobalOpacity), (GLfloat)q->state()->opacity); + opacityUniformDirty = false; + } + + return changed; } void QGL2PaintEngineExPrivate::composite(const QGLRect& boundingRect) @@ -971,6 +982,7 @@ void QGL2PaintEngineEx::opacityChanged() Q_ASSERT(d->shaderManager); d->brushUniformsDirty = true; + d->opacityUniformDirty = true; } void QGL2PaintEngineEx::compositionModeChanged() @@ -990,6 +1002,8 @@ void QGL2PaintEngineEx::renderHintsChanged() glDisable(GL_MULTISAMPLE); #endif + Q_D(QGL2PaintEngineEx); + d->lastTexture = GLuint(-1); // qDebug("QGL2PaintEngineEx::renderHintsChanged() not implemented!"); } @@ -1008,11 +1022,13 @@ void QGL2PaintEngineEx::drawPixmap(const QRectF& dest, const QPixmap & pixmap, c QGLContext *ctx = d->ctx; glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT); - ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA, true); + GLuint id = ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA, true); bool isBitmap = pixmap.isQBitmap(); bool isOpaque = !isBitmap && !pixmap.hasAlphaChannel(); + d->updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, + state()->renderHints & QPainter::SmoothPixmapTransform, id); d->drawTexture(dest, src, pixmap.size(), isOpaque, isBitmap); } @@ -1025,8 +1041,10 @@ void QGL2PaintEngineEx::drawImage(const QRectF& dest, const QImage& image, const QGLContext *ctx = d->ctx; glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT); - ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, true); + GLuint id = ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, true); + d->updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, + state()->renderHints & QPainter::SmoothPixmapTransform, id); d->drawTexture(dest, src, image.size(), !image.hasAlphaChannel()); } @@ -1121,7 +1139,7 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, const QTextIte prepareForDraw(false); // Text always causes src pixels to be transparent - shaderManager->currentProgram()->setUniformValue("maskTexture", QT_MASK_TEXTURE_UNIT); + shaderManager->currentProgram()->setUniformValue(location(MaskTexture), QT_MASK_TEXTURE_UNIT); if (vertexCoordinateArray.data() != oldVertexCoordinateDataPtr) glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray.data()); @@ -1161,9 +1179,27 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev) qt_resolve_version_2_0_functions(d->ctx); #endif - if (!d->shaderManager) + if (!d->shaderManager) { d->shaderManager = new QGLEngineShaderManager(d->ctx); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::ImageTexture] = d->shaderManager->getUniformIdentifier("imageTexture"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::PatternColor] = d->shaderManager->getUniformIdentifier("patternColor"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::GlobalOpacity] = d->shaderManager->getUniformIdentifier("globalOpacity"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::Depth] = d->shaderManager->getUniformIdentifier("depth"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::PmvMatrix] = d->shaderManager->getUniformIdentifier("pmvMatrix"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::MaskTexture] = d->shaderManager->getUniformIdentifier("maskTexture"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::FragmentColor] = d->shaderManager->getUniformIdentifier("fragmentColor"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::LinearData] = d->shaderManager->getUniformIdentifier("linearData"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::Angle] = d->shaderManager->getUniformIdentifier("angle"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::HalfViewportSize] = d->shaderManager->getUniformIdentifier("halfViewportSize"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::Fmp] = d->shaderManager->getUniformIdentifier("fmp"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::Fmp2MRadius2] = d->shaderManager->getUniformIdentifier("fmp2_m_radius2"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::Inverse2Fmp2MRadius2] = d->shaderManager->getUniformIdentifier("inverse_2_fmp2_m_radius2"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::InvertedTextureSize] = d->shaderManager->getUniformIdentifier("invertedTextureSize"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::BrushTransform] = d->shaderManager->getUniformIdentifier("brushTransform"); + d->uniformIdentifiers[QGL2PaintEngineExPrivate::BrushTexture] = d->shaderManager->getUniformIdentifier("brushTexture"); + } + glViewport(0, 0, d->width, d->height); // glClearColor(0.0, 1.0, 0.0, 1.0); @@ -1179,6 +1215,7 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev) d->stencilBufferDirty = true; d->simpleShaderDepthUniformDirty = true; d->depthUniformDirty = true; + d->opacityUniformDirty = true; d->use_system_clip = !systemClip().isEmpty(); @@ -1210,6 +1247,7 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev) source->bind(false); QRect rect(0, 0, source->width(), source->height()); + d->updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, false); d->drawTexture(QRectF(rect), QRectF(rect), rect.size(), true); } @@ -1506,6 +1544,7 @@ void QGL2PaintEngineEx::setState(QPainterState *new_state) d->depthUniformDirty = true; d->simpleShaderMatrixUniformDirty = true; d->shaderMatrixUniformDirty = true; + d->opacityUniformDirty = true; if (old_state && old_state != s && old_state->canRestoreClip) { d->updateDepthScissorTest(); diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h index a2a44c0..448964b 100644 --- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h @@ -156,7 +156,7 @@ public: void updateBrushUniforms(); void updateMatrix(); void updateCompositionMode(); - void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform); + void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id = -1); void setBrush(const QBrush* brush); @@ -175,7 +175,8 @@ public: void fillStencilWithVertexArray(QGL2PEXVertexArray& vertexArray, bool useWindingFill); // ^ Calls drawVertexArrays to render into stencil buffer - void prepareForDraw(bool srcPixelsAreOpaque); + bool prepareForDraw(bool srcPixelsAreOpaque); + // ^ returns whether the current program changed or not inline void useSimpleShader(); inline QColor premultiplyColor(QColor c, GLfloat opacity); @@ -198,6 +199,7 @@ public: bool stencilBufferDirty; bool depthUniformDirty; bool simpleShaderDepthUniformDirty; + bool opacityUniformDirty; const QBrush* currentBrush; // May not be the state's brush! @@ -218,6 +220,34 @@ public: void regenerateDepthClip(); void systemStateChanged(); uint use_system_clip : 1; + + enum Uniform { + ImageTexture, + PatternColor, + GlobalOpacity, + Depth, + PmvMatrix, + MaskTexture, + FragmentColor, + LinearData, + Angle, + HalfViewportSize, + Fmp, + Fmp2MRadius2, + Inverse2Fmp2MRadius2, + InvertedTextureSize, + BrushTransform, + BrushTexture, + NumUniforms + }; + + uint location(Uniform uniform) + { + return shaderManager->getUniformLocation(uniformIdentifiers[uniform]); + } + + uint uniformIdentifiers[NumUniforms]; + GLuint lastTexture; }; QT_END_NAMESPACE |