Moved uniform enum to QGLEngineShaderManager.

Simplified caching of uniform locations.

Reviewed-by: Samuel

4 files changed, 69 insertions, 83 deletions

diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
index 4b73ca9..27636f4 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
@@ -190,27 +190,33 @@ QGLEngineShaderManager::~QGLEngineShaderManager()
     //###
 }
 
-
-uint QGLEngineShaderManager::getUniformIdentifier(const char *uniformName)
-{
-    uniformIdentifiers << uniformName;
-    return uniformIdentifiers.size() - 1;
-}
-
-uint QGLEngineShaderManager::getUniformLocation(uint id)
+uint QGLEngineShaderManager::getUniformLocation(Uniform 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.isEmpty())
+        uniformLocations.fill(GLuint(-1), NumUniforms);
+
+    static const char *uniformNames[] = {
+        "imageTexture",
+        "patternColor",
+        "globalOpacity",
+        "depth",
+        "pmvMatrix",
+        "maskTexture",
+        "fragmentColor",
+        "linearData",
+        "angle",
+        "halfViewportSize",
+        "fmp",
+        "fmp2_m_radius2",
+        "inverse_2_fmp2_m_radius2",
+        "invertedTextureSize",
+        "brushTransform",
+        "brushTexture"
+    };
 
     if (uniformLocations.at(id) == GLuint(-1))
-        uniformLocations[id] = currentShaderProg->program->uniformLocation(uniformIdentifiers.at(id));
+        uniformLocations[id] = currentShaderProg->program->uniformLocation(uniformNames[id]);
 
     return uniformLocations.at(id);
 }
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
index 34f0768..442edfe 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
@@ -274,6 +274,26 @@ public:
         TextureSrcWithPattern = Qt::TexturePattern+4
     };
 
+    enum Uniform {
+        ImageTexture,
+        PatternColor,
+        GlobalOpacity,
+        Depth,
+        PmvMatrix,
+        MaskTexture,
+        FragmentColor,
+        LinearData,
+        Angle,
+        HalfViewportSize,
+        Fmp,
+        Fmp2MRadius2,
+        Inverse2Fmp2MRadius2,
+        InvertedTextureSize,
+        BrushTransform,
+        BrushTexture,
+        NumUniforms
+    };
+
     // There are optimisations we can do, depending on the brush transform:
     //    1) May not have to apply perspective-correction
     //    2) Can use lower precision for matrix
@@ -285,8 +305,7 @@ public:
     void setMaskType(MaskType);
     void setCompositionMode(QPainter::CompositionMode);
 
-    uint getUniformIdentifier(const char *uniformName);
-    uint getUniformLocation(uint id);
+    uint getUniformLocation(Uniform id);
 
     void setDirty(); // someone has manually changed the current shader program
     bool useCorrectShaderProg(); // returns true if the shader program needed to be changed
@@ -352,6 +371,7 @@ public:
         TotalShaderCount, InvalidShaderName
     };
 
+
 /*
     // These allow the ShaderName enum to be used as a cache key
     const int mainVertexOffset = 0;
@@ -391,8 +411,6 @@ 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 f261ca2..bcff29b 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -393,7 +393,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
 
     if (style == Qt::SolidPattern) {
         QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity);
-        shaderManager->currentProgram()->setUniformValue(location(FragmentColor), col);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::FragmentColor), col);
     }
     else {
         // All other brushes have a transform and thus need the translation point:
@@ -404,10 +404,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
 
             QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity);
 
-            shaderManager->currentProgram()->setUniformValue(location(PatternColor), col);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
-            shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
         }
         else if (style == Qt::LinearGradientPattern) {
             const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush->gradient());
@@ -424,10 +424,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
                 1.0f / (l.x() * l.x() + l.y() * l.y())
             );
 
-            shaderManager->currentProgram()->setUniformValue(location(LinearData), linearData);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::LinearData), linearData);
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
-            shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
         }
         else if (style == Qt::ConicalGradientPattern) {
             const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush->gradient());
@@ -435,10 +435,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
 
             GLfloat angle = -(g->angle() * 2 * Q_PI) / 360.0;
 
-            shaderManager->currentProgram()->setUniformValue(location(Angle), angle);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Angle), angle);
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
-            shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
         }
         else if (style == Qt::RadialGradientPattern) {
             const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush->gradient());
@@ -448,15 +448,15 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
             translationPoint   = realFocal;
 
             QPointF fmp = realCenter - realFocal;
-            shaderManager->currentProgram()->setUniformValue(location(Fmp), fmp);
+            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(Fmp2MRadius2), fmp2_m_radius2);
-            shaderManager->currentProgram()->setUniformValue(location(Inverse2Fmp2MRadius2),
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Inverse2Fmp2MRadius2),
                                                              GLfloat(1.0 / (2.0*fmp2_m_radius2)));
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
-            shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
         }
         else if (style == Qt::TexturePattern) {
             translationPoint = q->state()->brushOrigin;
@@ -465,14 +465,14 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
 
             if (qHasPixmapTexture(*currentBrush) && currentBrush->texture().isQBitmap()) {
                 QColor col = premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity);
-                shaderManager->currentProgram()->setUniformValue(location(PatternColor), col);
+                shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
             }
 
             QSizeF invertedTextureSize( 1.0 / texPixmap.width(), 1.0 / texPixmap.height() );
-            shaderManager->currentProgram()->setUniformValue(location(InvertedTextureSize), invertedTextureSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::InvertedTextureSize), invertedTextureSize);
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
-            shaderManager->currentProgram()->setUniformValue(location(HalfViewportSize), halfViewportSize);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
         }
         else
             qWarning("QGL2PaintEngineEx: Unimplemented fill style");
@@ -481,8 +481,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(location(BrushTransform), inv_matrix);
-        shaderManager->currentProgram()->setUniformValue(location(BrushTexture), QT_BRUSH_TEXTURE_UNIT);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTransform), inv_matrix);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTexture), QT_BRUSH_TEXTURE_UNIT);
     }
     brushUniformsDirty = false;
 }
@@ -620,11 +620,11 @@ void QGL2PaintEngineExPrivate::drawTexture(const QGLRect& dest, const QGLRect& s
     shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc);
     shaderManager->setTextureCoordsEnabled(true);
     if (prepareForDraw(opaque))
-        shaderManager->currentProgram()->setUniformValue(location(ImageTexture), QT_IMAGE_TEXTURE_UNIT);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
 
     if (pattern) {
         QColor col = premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
-        shaderManager->currentProgram()->setUniformValue(location(PatternColor), col);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
     }
 
     GLfloat dx = 1.0 / textureSize.width();
@@ -873,17 +873,17 @@ bool QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque)
         updateBrushUniforms();
 
     if (shaderMatrixUniformDirty) {
-        shaderManager->currentProgram()->setUniformValue(location(PmvMatrix), pmvMatrix);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PmvMatrix), pmvMatrix);
         shaderMatrixUniformDirty = false;
     }
 
     if (depthUniformDirty) {
-        shaderManager->currentProgram()->setUniformValue(location(Depth), (GLfloat)q->state()->currentDepth);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Depth), (GLfloat)q->state()->currentDepth);
         depthUniformDirty = false;
     }
 
     if (useGlobalOpacityUniform && opacityUniformDirty) {
-        shaderManager->currentProgram()->setUniformValue(location(GlobalOpacity), (GLfloat)q->state()->opacity);
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::GlobalOpacity), (GLfloat)q->state()->opacity);
         opacityUniformDirty = false;
     }
 
@@ -1166,7 +1166,7 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, const QTextIte
 
     prepareForDraw(false); // Text always causes src pixels to be transparent
 
-    shaderManager->currentProgram()->setUniformValue(location(MaskTexture), QT_MASK_TEXTURE_UNIT);
+    shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::MaskTexture), QT_MASK_TEXTURE_UNIT);
 
     if (vertexCoordinateArray.data() != oldVertexCoordinateDataPtr)
         glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray.data());
@@ -1210,23 +1210,6 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev)
         d->shaderManager->setDirty();
     } else {
         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);
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
index 0d28a49..ec447a3 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
@@ -221,32 +221,11 @@ public:
     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)
+    uint location(QGLEngineShaderManager::Uniform uniform)
     {
-        return shaderManager->getUniformLocation(uniformIdentifiers[uniform]);
+        return shaderManager->getUniformLocation(uniform);
     }
 
-    uint uniformIdentifiers[NumUniforms];
     GLuint lastTexture;
 
     bool needsSync;