Changeset 651 for trunk/src/opengl

trunk

Property svn:mergeinfo changed
/branches/vendor/nokia/qt/4.6.2 (added) merged: 650
/branches/vendor/nokia/qt/current merged: 649
/branches/vendor/nokia/qt/4.6.1 removed

trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglcustomshaderstage.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglcustomshaderstage_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglengineshadermanager.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     simpleShaderProg->addShader(fragShader);
     simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+    simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+    simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+    simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
     simpleShaderProg->link();
     if (!simpleShaderProg->isLinked()) {
 …
+    }
+}
+QGLEngineSharedShaders::~QGLEngineSharedShaders()
+{
+    QList<QGLEngineShaderProg*>::iterator itr;
+    for (itr = cachedPrograms.begin(); itr != cachedPrograms.end(); ++itr)
+        delete *itr;
+    if (blitShaderProg) {
+        delete blitShaderProg;
+        blitShaderProg = 0;
+    }
+    if (simpleShaderProg) {
+        delete simpleShaderProg;
+        simpleShaderProg = 0;
+    }
+}
 …
         if (newProg->useOpacityAttribute)
             newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
+        if (newProg->usePmvMatrix) {
+            newProg->program->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+            newProg->program->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+            newProg->program->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
+        }
         newProg->program->link();
 …
+}
 GLuint QGLEngineShaderManager::getUniformLocation(const Uniform id)
+GLuint QGLEngineShaderManager::getUniformLocation(Uniform id)
+{
     if (!currentShaderProg)
 …
         "globalOpacity",
         "depth",
-        "pmvMatrix",
         "maskTexture",
         "fragmentColor",
 …
 void QGLEngineShaderManager::optimiseForBrushTransform(const QTransform::TransformationType transformType)
+void QGLEngineShaderManager::optimiseForBrushTransform(QTransform::TransformationType transformType)
+{
     Q_UNUSED(transformType); // Currently ignored
 …
         return currentShaderProg->program;
     else
+        return simpleProgram();
+        return sharedShaders->simpleProgram();
+}
+void QGLEngineShaderManager::useSimpleProgram()
+{
+    sharedShaders->simpleProgram()->bind();
+    QGLContextPrivate* ctx_d = ctx->d_func();
+    ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
+    ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+    shaderProgNeedsChanging = true;
+}
+void QGLEngineShaderManager::useBlitProgram()
+{
+    sharedShaders->blitProgram()->bind();
+    QGLContextPrivate* ctx_d = ctx->d_func();
+    ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, true);
+    ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+    shaderProgNeedsChanging = true;
+}
 …
     requiredProgram.useTextureCoords = texCoords;
     requiredProgram.useOpacityAttribute = (opacityMode == AttributeOpacity);
+    requiredProgram.usePmvMatrix = true;
     // At this point, requiredProgram is fully populated so try to find the program in the cache
 …
+    }
+    // Make sure all the vertex attribute arrays the program uses are enabled (and the ones it
+    // doesn't use are disabled)
+    QGLContextPrivate* ctx_d = ctx->d_func();
+    ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, currentShaderProg->useTextureCoords);
+    ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, currentShaderProg->useOpacityAttribute);
     shaderProgNeedsChanging = false;
     return true;

trunk/src/opengl/gl2paintengineex/qglengineshadermanager_p.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 static const GLuint QT_TEXTURE_COORDS_ATTR = 1;
 static const GLuint QT_OPACITY_ATTR = 2;
+static const GLuint QT_PMV_MATRIX_1_ATTR = 3;
+static const GLuint QT_PMV_MATRIX_2_ATTR = 4;
+static const GLuint QT_PMV_MATRIX_3_ATTR = 5;
 class QGLEngineShaderProg;
 …
     QGLEngineSharedShaders(const QGLContext *context);
+    ~QGLEngineSharedShaders();
     QGLShaderProgram *simpleProgram() { return simpleShaderProg; }
 …
     bool                useTextureCoords;
     bool                useOpacityAttribute;
+    bool                usePmvMatrix;
     bool operator==(const QGLEngineShaderProg& other) {
 …
         GlobalOpacity,
         Depth,
-        PmvMatrix,
         MaskTexture,
         FragmentColor,
 …
     //    1) May not have to apply perspective-correction
     //    2) Can use lower precision for matrix
     void optimiseForBrushTransform(const QTransform::TransformationType transformType);
+    void optimiseForBrushTransform(QTransform::TransformationType transformType);
     void setSrcPixelType(Qt::BrushStyle);
     void setSrcPixelType(PixelSrcType); // For non-brush sources, like pixmaps & images
 …
     void removeCustomStage();
     GLuint getUniformLocation(const Uniform id);
+    GLuint 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
+    void useSimpleProgram();
+    void useBlitProgram();
     QGLShaderProgram* currentProgram(); // Returns pointer to the shader the manager has chosen

trunk/src/opengl/gl2paintengineex/qglengineshadersource_p.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+static const char* const qglslMainVertexShader = "\
+    uniform   highp float   depth;\
+    void setPosition();\
+    void main(void)\
+    {\
+            setPosition();\
+            gl_Position.z = depth * gl_Position.w;\
+    }";
+static const char* const qglslMainWithTexCoordsVertexShader = "\
+    attribute highp  vec2 textureCoordArray; \
+    varying   highp  vec2 textureCoords; \
+    uniform   highp float   depth;\
+    void setPosition();\
+    void main(void) \
+    {\
+            setPosition();\
+            gl_Position.z = depth * gl_Position.w;\
+            textureCoords = textureCoordArray; \
+    }";
+static const char* const qglslMainWithTexCoordsAndOpacityVertexShader = "\
+    attribute highp vec2  textureCoordArray; \
+    attribute lowp  float opacityArray; \
+    varying   highp vec2  textureCoords; \
+    varying   lowp  float opacity; \
+    uniform   highp float depth; \
+    void setPosition(); \
+    void main(void) \
+    { \
+            setPosition(); \
+            gl_Position.z = depth * gl_Position.w; \
+            textureCoords = textureCoordArray; \
+            opacity = opacityArray; \
+    }";
+static const char* const qglslMainVertexShader = "\n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+    }\n";
+static const char* const qglslMainWithTexCoordsVertexShader = "\n\
+    attribute highp   vec2      textureCoordArray; \n\
+    varying   highp   vec2      textureCoords; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+    }\n";
+static const char* const qglslMainWithTexCoordsAndOpacityVertexShader = "\n\
+    attribute highp   vec2      textureCoordArray; \n\
+    attribute lowp    float     opacityArray; \n\
+    varying   highp   vec2      textureCoords; \n\
+    varying   lowp    float     opacity; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+        opacity = opacityArray; \n\
+    }\n";
 // NOTE: We let GL do the perspective correction so texture lookups in the fragment
 //       shader are also perspective corrected.
+static const char* const qglslPositionOnlyVertexShader = "\
+    attribute highp vec2    vertexCoordsArray;\
+    uniform   highp mat3    pmvMatrix;\
+    void setPosition(void)\
+    {\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+        gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \
+    }";
+static const char* const qglslUntransformedPositionVertexShader = "\
+    attribute highp vec4    vertexCoordsArray;\
+    void setPosition(void)\
+    {\
+            gl_Position = vertexCoordsArray;\
+    }";
+static const char* const qglslPositionOnlyVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \n\
+    }\n";
+static const char* const qglslUntransformedPositionVertexShader = "\n\
+    attribute highp   vec4      vertexCoordsArray; \n\
+    void setPosition(void) \n\
+    { \n\
+        gl_Position = vertexCoordsArray; \n\
+    }\n";
 // Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125
+static const char* const qglslPositionWithPatternBrushVertexShader = "\
+    attribute highp   vec2  vertexCoordsArray; \
+    uniform   highp   mat3  pmvMatrix; \
+    uniform   mediump vec2  halfViewportSize; \
+    uniform   highp   vec2  invertedTextureSize; \
+    uniform   highp   mat3  brushTransform; \
+    varying   highp   vec2  patternTexCoords; \
+    void setPosition(void) { \
+            vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+            gl_Position.xy = transformedPos.xy / transformedPos.z; \
+            mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
+            mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \
+            mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
+            gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \
+            patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \
+    }";
+static const char* const qglslPositionWithPatternBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec2      invertedTextureSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      patternTexCoords; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \n\
+    }\n";
 static const char* const qglslAffinePositionWithPatternBrushVertexShader
                  = qglslPositionWithPatternBrushVertexShader;
+static const char* const qglslPatternBrushSrcFragmentShader = "\
+    uniform lowp    sampler2D brushTexture;\
+    uniform lowp    vec4      patternColor; \
+    varying highp   vec2      patternTexCoords;\
+    lowp vec4 srcPixel() { \
+        return patternColor * (1.0 - texture2D(brushTexture, patternTexCoords).r); \
+static const char* const qglslPatternBrushSrcFragmentShader = "\n\
+    uniform   lowp    sampler2D brushTexture; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    varying   highp   vec2      patternTexCoords;\n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(brushTexture, patternTexCoords).r); \n\
     }\n";
 // Linear Gradient Brush
+static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\
+    attribute highp   vec2  vertexCoordsArray; \
+    uniform   highp   mat3  pmvMatrix; \
+    uniform   mediump vec2  halfViewportSize; \
+    uniform   highp   vec3  linearData; \
+    uniform   highp   mat3  brushTransform; \
+    varying   mediump float index; \
+    void setPosition() { \
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \
+        index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \
+    }";
+static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec3      linearData; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   mediump float     index; \n\
+    void setPosition() \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \n\
+    }\n";
 static const char* const qglslAffinePositionWithLinearGradientBrushVertexShader
                  = qglslPositionWithLinearGradientBrushVertexShader;
+static const char* const qglslLinearGradientBrushSrcFragmentShader = "\
+    uniform lowp    sampler2D   brushTexture; \
+    varying mediump float       index; \
+    lowp vec4 srcPixel() { \
+        mediump vec2 val = vec2(index, 0.5); \
+        return texture2D(brushTexture, val); \
+static const char* const qglslLinearGradientBrushSrcFragmentShader = "\n\
+    uniform   lowp    sampler2D brushTexture; \n\
+    varying   mediump float     index; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        mediump vec2 val = vec2(index, 0.5); \n\
+        return texture2D(brushTexture, val); \n\
     }\n";
 // Conical Gradient Brush
+static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\
+    attribute highp   vec2  vertexCoordsArray;\
+    uniform   highp   mat3  pmvMatrix;\
+    uniform   mediump vec2  halfViewportSize; \
+    uniform   highp   mat3  brushTransform; \
+    varying   highp   vec2  A; \
+    void setPosition(void)\
+    {\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \
+        mediump vec2  viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \
+        A = hTexCoords.xy * invertedHTexCoordsZ; \
+    }";
+static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      A; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2  viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+    }\n";
 static const char* const qglslAffinePositionWithConicalGradientBrushVertexShader
 …
 static const char* const qglslConicalGradientBrushSrcFragmentShader = "\n\
     #define INVERSE_2PI 0.1591549430918953358 \n\
+    uniform lowp    sampler2D   brushTexture; \n\
+    uniform mediump float       angle; \
+    varying highp   vec2        A; \
+    lowp vec4 srcPixel() { \
+        highp float t; \
+        if (abs(A.y) == abs(A.x)) \
+            t = (atan(-A.y + 0.002, A.x) + angle) * INVERSE_2PI; \
+        else \
+            t = (atan(-A.y, A.x) + angle) * INVERSE_2PI; \
+        return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \
+    }";
+    uniform   lowp    sampler2D brushTexture; \n\
+    uniform   mediump float     angle; \n\
+    varying   highp   vec2      A; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        highp float t; \n\
+        if (abs(A.y) == abs(A.x)) \n\
+            t = (atan(-A.y + 0.002, A.x) + angle) * INVERSE_2PI; \n\
+        else \n\
+            t = (atan(-A.y, A.x) + angle) * INVERSE_2PI; \n\
+        return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \n\
+    }\n";
 // Radial Gradient Brush
+static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\
+    attribute highp   vec2 vertexCoordsArray;\
+    uniform   highp   mat3 pmvMatrix;\
+    uniform   mediump vec2 halfViewportSize; \
+    uniform   highp   mat3 brushTransform; \
+    uniform   highp   vec2 fmp; \
+    varying   highp   float b; \
+    varying   highp   vec2  A; \
+    void setPosition(void) \
+    {\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \
+        A = hTexCoords.xy * invertedHTexCoordsZ; \
+        b = 2.0 * dot(A, fmp); \
+    }";
+static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray;\n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    uniform   highp   vec2      fmp; \n\
+    varying   highp   float     b; \n\
+    varying   highp   vec2      A; \n\
+    void setPosition(void) \n\
+    {\n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+        b = 2.0 * dot(A, fmp); \n\
+    }\n";
 static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader
                  = qglslPositionWithRadialGradientBrushVertexShader;
+static const char* const qglslRadialGradientBrushSrcFragmentShader = "\
+    uniform lowp    sampler2D   brushTexture; \
+    uniform highp   float       fmp2_m_radius2; \
+    uniform highp   float       inverse_2_fmp2_m_radius2; \
+    varying highp   float       b; \
+    varying highp   vec2        A; \
+    lowp vec4 srcPixel() { \
+        highp float c = -dot(A, A); \
+        highp vec2 val = vec2((-b + sqrt(b*b - 4.0*fmp2_m_radius2*c)) * inverse_2_fmp2_m_radius2, 0.5); \
+        return texture2D(brushTexture, val); \
+    }";
+static const char* const qglslRadialGradientBrushSrcFragmentShader = "\n\
+    uniform   lowp    sampler2D brushTexture; \n\
+    uniform   highp   float     fmp2_m_radius2; \n\
+    uniform   highp   float     inverse_2_fmp2_m_radius2; \n\
+    varying   highp   float     b; \n\
+    varying   highp   vec2      A; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        highp float c = -dot(A, A); \n\
+        highp vec2 val = vec2((-b + sqrt(b*b - 4.0*fmp2_m_radius2*c)) * inverse_2_fmp2_m_radius2, 0.5); \n\
+        return texture2D(brushTexture, val); \n\
+    }\n";
 // Texture Brush
+static const char* const qglslPositionWithTextureBrushVertexShader = "\
+    attribute highp   vec2 vertexCoordsArray; \
+    uniform   highp   mat3  pmvMatrix; \
+    uniform   mediump vec2  halfViewportSize; \
+    uniform   highp   vec2  invertedTextureSize; \
+    uniform   highp   mat3  brushTransform; \
+    varying   highp   vec2  textureCoords; \
+    void setPosition(void) { \
+            vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \
+            gl_Position.xy = transformedPos.xy / transformedPos.z; \
+            mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
+            mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \
+            mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
+            gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \
+            textureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \
+    }";
+static const char* const qglslPositionWithTextureBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec2      invertedTextureSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      textureCoords; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        textureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
+    }\n";
 static const char* const qglslAffinePositionWithTextureBrushVertexShader
 …
 // we emulate GL_REPEAT by only taking the fractional part of the texture coords.
 // TODO: Special case POT textures which don't need this emulation
 static const char* const qglslTextureBrushSrcFragmentShader = "\
     varying highp   vec2      textureCoords; \
     uniform lowp    sampler2D brushTexture; \
     lowp vec4 srcPixel() { \
         return texture2D(brushTexture, fract(textureCoords)); \
     }";
+static const char* const qglslTextureBrushSrcFragmentShader = "\n\
+    varying highp   vec2      textureCoords; \n\
+    uniform lowp    sampler2D brushTexture; \n\
+    lowp vec4 srcPixel() { \n\
+        return texture2D(brushTexture, fract(textureCoords)); \n\
+    }\n";
 #else
+static const char* const qglslTextureBrushSrcFragmentShader = "\
+    varying highp   vec2      textureCoords; \
+    uniform lowp    sampler2D brushTexture; \
+    lowp vec4 srcPixel() { \
+        return texture2D(brushTexture, textureCoords); \
+    }";
+static const char* const qglslTextureBrushSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    sampler2D brushTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return texture2D(brushTexture, textureCoords); \n\
+    }\n";
 #endif
+static const char* const qglslTextureBrushSrcWithPatternFragmentShader = "\
+    varying highp   vec2      textureCoords; \
+    uniform lowp    vec4      patternColor; \
+    uniform lowp    sampler2D brushTexture; \
+    lowp vec4 srcPixel() { \
+        return patternColor * (1.0 - texture2D(brushTexture, textureCoords).r); \
+    }";
+static const char* const qglslTextureBrushSrcWithPatternFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    uniform   lowp    sampler2D brushTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(brushTexture, textureCoords).r); \n\
+    }\n";
 // Solid Fill Brush
+static const char* const qglslSolidBrushSrcFragmentShader = "\
+    uniform lowp vec4 fragmentColor; \
+    lowp vec4 srcPixel() { \
+        return fragmentColor; \
+    }";
+static const char* const qglslImageSrcFragmentShader = "\
+    varying highp   vec2    textureCoords; \
+    uniform lowp  sampler2D imageTexture; \
+    lowp vec4 srcPixel() { \
+        return texture2D(imageTexture, textureCoords); \
+    }";
+static const char* const qglslCustomSrcFragmentShader = "\
+    varying highp vec2      textureCoords; \
+    uniform lowp  sampler2D imageTexture; \
+    lowp vec4 customShader(lowp sampler2D texture, highp vec2 coords); \
+    lowp vec4 srcPixel() { \
+        return customShader(imageTexture, textureCoords); \
+    }";
+static const char* const qglslImageSrcWithPatternFragmentShader = "\
+    varying highp vec2      textureCoords; \
+    uniform lowp  vec4      patternColor; \
+    uniform lowp  sampler2D imageTexture; \
+    lowp vec4 srcPixel() { \
+        return patternColor * (1.0 - texture2D(imageTexture, textureCoords).r); \
+    }\n";
+static const char* const qglslNonPremultipliedImageSrcFragmentShader = "\
+    varying highp vec2      textureCoords; \
+    uniform lowp  sampler2D imageTexture; \
+    lowp vec4 srcPixel() { \
+        lowp vec4 sample = texture2D(imageTexture, textureCoords); \
+        sample.rgb = sample.rgb * sample.a; \
+        return sample; \
+    }";
+static const char* const qglslShockingPinkSrcFragmentShader = "\
+    lowp vec4 srcPixel() { \
+        return vec4(0.98, 0.06, 0.75, 1.0); \
+    }";
+static const char* const qglslMainFragmentShader_ImageArrays = "\
+    varying lowp float opacity; \
+    lowp vec4 srcPixel(); \
+    void main() { \
+        gl_FragColor = srcPixel() * opacity; \
+    }";
+static const char* const qglslMainFragmentShader_CMO = "\
+    uniform lowp float globalOpacity; \
+    lowp vec4 srcPixel(); \
+    lowp vec4 applyMask(lowp vec4); \
+    lowp vec4 compose(lowp vec4); \
+    void main() { \
+        gl_FragColor = applyMask(compose(srcPixel()*globalOpacity))); \
+    }";
+static const char* const qglslMainFragmentShader_CM = "\
+    lowp vec4 srcPixel(); \
+    lowp vec4 applyMask(lowp vec4); \
+    lowp vec4 compose(lowp vec4); \
+    void main() { \
+        gl_FragColor = applyMask(compose(srcPixel())); \
+    }";
+static const char* const qglslMainFragmentShader_MO = "\
+    uniform lowp float globalOpacity; \
+    lowp vec4 srcPixel(); \
+    lowp vec4 applyMask(lowp vec4); \
+    void main() { \
+        gl_FragColor = applyMask(srcPixel()*globalOpacity); \
+    }";
+static const char* const qglslMainFragmentShader_M = "\
+    lowp vec4 srcPixel(); \
+    lowp vec4 applyMask(lowp vec4); \
+    void main() { \
+        gl_FragColor = applyMask(srcPixel()); \
+    }";
+static const char* const qglslMainFragmentShader_CO = "\
+    uniform lowp float globalOpacity; \
+    lowp vec4 srcPixel(); \
+    lowp vec4 compose(lowp vec4); \
+    void main() { \
+        gl_FragColor = compose(srcPixel()*globalOpacity); \
+    }";
+static const char* const qglslMainFragmentShader_C = "\
+    lowp vec4 srcPixel(); \
+    lowp vec4 compose(lowp vec4); \
+    void main() { \
+        gl_FragColor = compose(srcPixel()); \
+    }";
+static const char* const qglslMainFragmentShader_O = "\
+    uniform lowp float globalOpacity; \
+    lowp vec4 srcPixel(); \
+    void main() { \
+        gl_FragColor = srcPixel()*globalOpacity; \
+    }";
+static const char* const qglslMainFragmentShader = "\
+    lowp vec4 srcPixel(); \
+    void main() { \
+        gl_FragColor = srcPixel(); \
+    }";
+static const char* const qglslMaskFragmentShader = "\
+    varying highp   vec2      textureCoords;\
+    uniform lowp    sampler2D maskTexture;\
+    lowp vec4 applyMask(lowp vec4 src) \
+    {\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \
+        return src * mask.a; \
+    }";
+static const char* const qglslSolidBrushSrcFragmentShader = "\n\
+    uniform   lowp    vec4      fragmentColor; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return fragmentColor; \n\
+    }\n";
+static const char* const qglslImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return texture2D(imageTexture, textureCoords); \n\
+    }\n";
+static const char* const qglslCustomSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    sampler2D imageTexture; \n\
+    lowp vec4 customShader(lowp sampler2D texture, highp vec2 coords); \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return customShader(imageTexture, textureCoords); \n\
+    }\n";
+static const char* const qglslImageSrcWithPatternFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    uniform   lowp    sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(imageTexture, textureCoords).r); \n\
+    }\n";
+static const char* const qglslNonPremultipliedImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        lowp vec4 sample = texture2D(imageTexture, textureCoords); \n\
+        sample.rgb = sample.rgb * sample.a; \n\
+        return sample; \n\
+    }\n";
+static const char* const qglslShockingPinkSrcFragmentShader = "\n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return vec4(0.98, 0.06, 0.75, 1.0); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_ImageArrays = "\n\
+    varying   lowp    float     opacity; \n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel() * opacity; \n\
+    }\n";
+static const char* const qglslMainFragmentShader_CMO = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    lowp vec4 compose(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(compose(srcPixel()*globalOpacity))); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_CM = "\n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    lowp vec4 compose(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(compose(srcPixel())); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_MO = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(srcPixel()*globalOpacity); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_M = "\n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(srcPixel()); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_CO = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 compose(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = compose(srcPixel()*globalOpacity); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_C = "\n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 compose(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = compose(srcPixel()); \n\
+    }\n";
+static const char* const qglslMainFragmentShader_O = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel()*globalOpacity; \n\
+    }\n";
+static const char* const qglslMainFragmentShader = "\n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel(); \n\
+    }\n";
+static const char* const qglslMaskFragmentShader = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform   lowp    sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    {\n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src * mask.a; \n\
+    }\n";
 // For source over with subpixel antialiasing, the final color is calculated per component as follows
 …
 //
 static const char* const qglslRgbMaskFragmentShaderPass1 = "\
     varying highp   vec2      textureCoords;\
     uniform lowp    sampler2D maskTexture;\
     lowp vec4 applyMask(lowp vec4 src) \
     {\
         lowp vec4 mask = texture2D(maskTexture, textureCoords); \
         return src.a * mask; \
     }";
 static const char* const qglslRgbMaskFragmentShaderPass2 = "\
     varying highp   vec2      textureCoords;\
     uniform lowp    sampler2D maskTexture;\
     lowp vec4 applyMask(lowp vec4 src) \
     {\
         lowp vec4 mask = texture2D(maskTexture, textureCoords); \
         return src * mask; \
     }";
+static const char* const qglslRgbMaskFragmentShaderPass1 = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform   lowp    sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    { \n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src.a * mask; \n\
+    }\n";
+static const char* const qglslRgbMaskFragmentShaderPass2 = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform   lowp    sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    { \n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src * mask; \n\
+    }\n";
 /*

trunk/src/opengl/gl2paintengineex/qglgradientcache.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglgradientcache_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qpainter_p.h>
 #include <private/qfontengine_p.h>
-#include <private/qtextureglyphcache_p.h>
 #include <private/qpixmapdata_gl_p.h>
 #include <private/qdatabuffer_p.h>
 …
 #include "qglengineshadermanager_p.h"
 #include "qgl2pexvertexarray_p.h"
 #include "qtriangulatingstroker_p.h"
+#include "qtextureglyphcache_gl_p.h"
 #include <QDebug>
 …
 //#define QT_GL_NO_SCISSOR_TEST
-static const GLuint GL_STENCIL_HIGH_BIT         = 0x80;
-static const GLuint QT_BRUSH_TEXTURE_UNIT       = 0;
-static const GLuint QT_IMAGE_TEXTURE_UNIT       = 0; //Can be the same as brush texture unit
-static const GLuint QT_MASK_TEXTURE_UNIT        = 1;
-static const GLuint QT_BACKGROUND_TEXTURE_UNIT  = 2;
-#ifdef Q_WS_WIN
-extern Q_GUI_EXPORT bool qt_cleartype_enabled;
-#endif
-class QGLTextureGlyphCache : public QObject, public QTextureGlyphCache
+{
-    Q_OBJECT
-public:
-    QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix);
-    ~QGLTextureGlyphCache();
-    virtual void createTextureData(int width, int height);
-    virtual void resizeTextureData(int width, int height);
-    virtual void fillTexture(const Coord &c, glyph_t glyph);
-    virtual int glyphMargin() const;
-    inline GLuint texture() const { return m_texture; }
-    inline int width() const { return m_width; }
-    inline int height() const { return m_height; }
-    inline void setPaintEnginePrivate(QGL2PaintEngineExPrivate *p) { pex = p; }
-public Q_SLOTS:
-    void contextDestroyed(const QGLContext *context) {
-        if (context == ctx) {
-            QList<const QGLContext *> shares = qgl_share_reg()->shares(ctx);
-            if (shares.isEmpty()) {
-                glDeleteFramebuffers(1, &m_fbo);
-                if (m_width || m_height)
-                    glDeleteTextures(1, &m_texture);
-                ctx = 0;
-            } else {
-                // since the context holding the texture is shared, and
-                // about to be destroyed, we have to transfer ownership
-                // of the texture to one of the share contexts
-                ctx = const_cast<QGLContext *>((ctx == shares.at(0)) ? shares.at(1) : shares.at(0));
+            }
+        }
+    }
-private:
-    QGLContext *ctx;
-    QGL2PaintEngineExPrivate *pex;
-    GLuint m_texture;
-    GLuint m_fbo;
-    int m_width;
-    int m_height;
-    QGLShaderProgram *m_program;
-};
-QGLTextureGlyphCache::QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix)
-    : QTextureGlyphCache(type, matrix)
-    , ctx(context)
-    , m_width(0)
-    , m_height(0)
+{
-    glGenFramebuffers(1, &m_fbo);
-    connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext*)),
-            SLOT(contextDestroyed(const QGLContext*)));
+}
-QGLTextureGlyphCache::~QGLTextureGlyphCache()
+{
-    if (ctx) {
-        QGLShareContextScope scope(ctx);
-        glDeleteFramebuffers(1, &m_fbo);
-        if (m_width || m_height)
-            glDeleteTextures(1, &m_texture);
+    }
+}
-void QGLTextureGlyphCache::createTextureData(int width, int height)
+{
-    glGenTextures(1, &m_texture);
-    glBindTexture(GL_TEXTURE_2D, m_texture);
-    m_width = width;
-    m_height = height;
-    QVarLengthArray<uchar> data(width * height);
-    for (int i = 0; i < data.size(); ++i)
-        data[i] = 0;
-    if (m_type == QFontEngineGlyphCache::Raster_RGBMask)
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
-    else
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+}
-void QGLTextureGlyphCache::resizeTextureData(int width, int height)
+{
-    // ### the QTextureGlyphCache API needs to be reworked to allow
-    // ### resizeTextureData to fail
-    int oldWidth = m_width;
-    int oldHeight = m_height;
-    GLuint oldTexture = m_texture;
-    createTextureData(width, height);
-    glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_fbo);
-    GLuint tmp_texture;
-    glGenTextures(1, &tmp_texture);
-    glBindTexture(GL_TEXTURE_2D, tmp_texture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
-                 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glBindTexture(GL_TEXTURE_2D, 0);
-    glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                           GL_TEXTURE_2D, tmp_texture, 0);
-    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
-    glBindTexture(GL_TEXTURE_2D, oldTexture);
-    pex->transferMode(BrushDrawingMode);
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_SCISSOR_TEST);
-    glDisable(GL_BLEND);
-    glViewport(0, 0, oldWidth, oldHeight);
-    float vertexCoordinateArray[] = { -1, -1, 1, -1, 1, 1, -1, 1 };
-    float textureCoordinateArray[] = { 0, 0, 1, 0, 1, 1, 0, 1 };
-    glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
-    glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
-    glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray);
-    glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray);
-    pex->shaderManager->blitProgram()->bind();
-    pex->shaderManager->blitProgram()->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
-    pex->shaderManager->setDirty();
-    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-    glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
-    glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
-    glBindTexture(GL_TEXTURE_2D, m_texture);
-#ifdef QT_OPENGL_ES_2
-    QDataBuffer<uchar> buffer(4*oldWidth*oldHeight);
-    buffer.resize(4*oldWidth*oldHeight);
-    glReadPixels(0, 0, oldWidth, oldHeight, GL_RGBA, GL_UNSIGNED_BYTE, buffer.data());
-    // do an in-place conversion from GL_RGBA to GL_ALPHA
-    for (int i=0; i<oldWidth*oldHeight; ++i)
-        buffer.data()[i] = buffer.at(4*i + 3);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, oldWidth, oldHeight,
-                    GL_ALPHA, GL_UNSIGNED_BYTE, buffer.data());
-#else
-    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
-#endif
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                              GL_RENDERBUFFER_EXT, 0);
-    glDeleteTextures(1, &tmp_texture);
-    glDeleteTextures(1, &oldTexture);
-    glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
-    glViewport(0, 0, pex->width, pex->height);
-    pex->updateClipScissorTest();
+}
-void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)
+{
-    QImage mask = textureMapForGlyph(glyph);
-    const int maskWidth = mask.width();
-    const int maskHeight = mask.height();
-    if (mask.format() == QImage::Format_Mono) {
-        mask = mask.convertToFormat(QImage::Format_Indexed8);
-        for (int y = 0; y < maskHeight; ++y) {
-            uchar *src = (uchar *) mask.scanLine(y);
-            for (int x = 0; x < maskWidth; ++x)
-                src[x] = -src[x]; // convert 0 and 1 into 0 and 255
+        }
+     }
-    glBindTexture(GL_TEXTURE_2D, m_texture);
-    if (mask.format() == QImage::Format_RGB32) {
-        glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_BGRA, GL_UNSIGNED_BYTE, mask.bits());
-    } else {
-#ifdef QT_OPENGL_ES2
-        glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_ALPHA, GL_UNSIGNED_BYTE, mask.bits());
-#else
-        // glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is
-        // not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista
-        // and nVidia GeForce 8500GT. GL_UNPACK_ALIGNMENT is set to four bytes, 'mask' has a
-        // multiple of four bytes per line, and most of the glyph shows up correctly in the
-        // texture, which makes me think that this is a driver bug.
-        // One workaround is to make sure the mask width is a multiple of four bytes, for instance
-        // by converting it to a format with four bytes per pixel. Another is to copy one line at a
-        // time.
-        for (int i = 0; i < maskHeight; ++i)
-            glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, maskWidth, 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));
-#endif
+    }
+}
-int QGLTextureGlyphCache::glyphMargin() const
+{
-#if defined(Q_WS_MAC)
-    return 2;
-#elif defined (Q_WS_X11)
-    return 0;
-#else
-    return m_type == QFontEngineGlyphCache::Raster_RGBMask ? 2 : 0;
-#endif
+}
 extern QImage qt_imageForBrush(int brushStyle, bool invert);
 …
 void QGL2PaintEngineExPrivate::useSimpleShader()
+{
+    shaderManager->simpleProgram()->bind();
+    shaderManager->setDirty();
+    shaderManager->useSimpleProgram();
     if (matrixDirty)
         updateMatrix();
-    if (simpleShaderMatrixUniformDirty) {
-        const GLuint location = shaderManager->simpleProgram()->uniformLocation("pmvMatrix");
-        glUniformMatrix3fv(location, 1, GL_FALSE, (GLfloat*)pmvMatrix);
-        simpleShaderMatrixUniformDirty = false;
+    }
+}
 …
     matrixDirty = false;
+    // The actual data has been updated so both shader program's uniforms need updating
+    simpleShaderMatrixUniformDirty = true;
+    shaderMatrixUniformDirty = 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);
 …
     glUseProgram(0);
+    // Disable all the vertex attribute arrays:
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
+        glDisableVertexAttribArray(i);
 #ifndef QT_OPENGL_ES_2
     // be nice to people who mix OpenGL 1.x code with QPainter commands
 …
     glDepthFunc(GL_LESS);
     glClearDepth(1);
+    glStencilMask(0xff);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+    glStencilFunc(GL_ALWAYS, 0, 0xff);
+    glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
+    glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+    glDisableVertexAttribArray(QT_OPACITY_ATTR);
+#ifndef QT_OPENGL_ES_2
+    glColor4f(1.0f, 1.0f, 1.0f, 1.0f); // color may have been changed by glVertexAttrib()
+#endif
+}
 …
     if (mode == TextDrawingMode || mode == ImageDrawingMode || mode == ImageArrayDrawingMode) {
-        glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
-        glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
-        glDisableVertexAttribArray(QT_OPACITY_ATTR);
         lastTextureUsed = GLuint(-1);
+    }
     if (newMode == TextDrawingMode) {
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray.data());
+        glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray.data());
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
+        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
+    }
     if (newMode == ImageDrawingMode) {
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, staticVertexCoordinateArray);
+        glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, staticTextureCoordinateArray);
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
+        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, staticTextureCoordinateArray);
+    }
     if (newMode == ImageArrayDrawingMode) {
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
+        glEnableVertexAttribArray(QT_OPACITY_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray.data());
+        glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray.data());
+        glVertexAttribPointer(QT_OPACITY_ATTR, 1, GL_FLOAT, GL_FALSE, 0, opacityArray.data());
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
+        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
+        setVertexAttributePointer(QT_OPACITY_ATTR, (GLfloat*)opacityArray.data());
+    }
 …
             prepareForDraw(currentBrush.isOpaque());
-            glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
 #ifdef QT_OPENGL_CACHE_AS_VBOS
             glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
             glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, false, 0, 0);
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
 #else
             glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, false, 0, cache->vertices);
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
 #endif
             glDrawArrays(cache->primitiveType, 0, cache->vertexCount);
 …
 #if 0
         glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, data);
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
-        glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
 #else
 …
             glStencilFunc(GL_ALWAYS, GL_STENCIL_HIGH_BIT, 0xff);
+        }
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, data);
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
-        glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
 #endif
+    }
 …
         // The shader program has changed so mark all uniforms as dirty:
         brushUniformsDirty = true;
-        shaderMatrixUniformDirty = true;
         opacityUniformDirty = true;
+    }
 …
     if (brushUniformsDirty && mode != ImageDrawingMode && mode != ImageArrayDrawingMode)
         updateBrushUniforms();
-    if (shaderMatrixUniformDirty) {
-        glUniformMatrix3fv(location(QGLEngineShaderManager::PmvMatrix), 1, GL_FALSE, (GLfloat*)pmvMatrix);
-        shaderMatrixUniformDirty = false;
+    }
     if (opacityMode == QGLEngineShaderManager::UniformOpacity && opacityUniformDirty) {
 …
 void QGL2PaintEngineExPrivate::composite(const QGLRect& boundingRect)
+{
+    // Setup a vertex array for the bounding rect:
+    GLfloat rectVerts[] = {
+        boundingRect.left, boundingRect.top,
+        boundingRect.left, boundingRect.bottom,
+        boundingRect.right, boundingRect.bottom,
+        boundingRect.right, boundingRect.top
+    };
+    glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+    glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, rectVerts);
+    setCoords(staticVertexCoordinateArray, boundingRect);
+    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-    glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+}
 …
+{
     // Now setup the pointer to the vertex array:
+    glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+    glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, data);
+    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)data);
     int previousStop = 0;
 …
         previousStop = stop;
+    }
-    glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+}
 …
     if (opaque) {
         prepareForDraw(opaque);
+        glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, false, 0, stroker.vertices());
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, stroker.vertices());
         glDrawArrays(GL_TRIANGLE_STRIP, 0, stroker.vertexCount() / 2);
 …
 //         d->prepareForDraw(true);
 //         glDrawArrays(GL_LINE_STRIP, 0, d->stroker.vertexCount() / 2);
-        glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
     } else {
 …
     GLfloat dy = 1.0 / cache->height();
-    QGLPoint *oldVertexCoordinateDataPtr = vertexCoordinateArray.data();
-    QGLPoint *oldTextureCoordinateDataPtr = textureCoordinateArray.data();
     vertexCoordinateArray.clear();
     textureCoordinateArray.clear();
 …
+    }
+    if (vertexCoordinateArray.data() != oldVertexCoordinateDataPtr)
+        glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray.data());
+    if (textureCoordinateArray.data() != oldTextureCoordinateDataPtr)
+        glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray.data());
+    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
+    setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
     if (addOffset) {
 …
 #if !defined(QT_OPENGL_ES_2)
 #if defined(Q_WS_WIN)
+    extern Q_GUI_EXPORT bool qt_cleartype_enabled;
     if (qt_cleartype_enabled)
 #endif
 …
         d->needsSync = false;
         d->shaderManager->setDirty();
+        d->ctx->d_func()->syncGlState();
+        for (int i = 0; i < 3; ++i)
+            d->vertexAttribPointers[i] = (GLfloat*)-1; // Assume the pointers are clobbered
         setState(state());
+    }
 …
         renderHintsChanged();
     if (old_state == s || old_state->matrixChanged) {
+    if (old_state == s || old_state->matrixChanged)
         d->matrixDirty = true;
-        d->simpleShaderMatrixUniformDirty = true;
-        d->shaderMatrixUniformDirty = true;
+    }
     if (old_state == s || old_state->compositionModeChanged)
 …
 QT_END_NAMESPACE
-#include "qpaintengineex_opengl2.moc"

trunk/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QT_BEGIN_NAMESPACE
+#define GL_STENCIL_HIGH_BIT         GLuint(0x80)
+#define QT_BRUSH_TEXTURE_UNIT       GLuint(0)
+#define QT_IMAGE_TEXTURE_UNIT       GLuint(0) //Can be the same as brush texture unit
+#define QT_MASK_TEXTURE_UNIT        GLuint(1)
+#define QT_BACKGROUND_TEXTURE_UNIT  GLuint(2)
 class QGL2PaintEngineExPrivate;
 …
     void drawCachedGlyphs(const QPointF &p, QFontEngineGlyphCache::Type glyphType, const QTextItemInt &ti);
+    // Calls glVertexAttributePointer if the pointer has changed
+    inline void setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer);
     // draws whatever is in the vertex array:
     void drawVertexArrays(const float *data, int *stops, int stopCount, GLenum primitive);
 …
     void regenerateClip();
     void systemStateChanged();
     static QGLEngineShaderManager* shaderManagerForEngine(QGL2PaintEngineEx *engine) { return engine->d_func()->shaderManager; }
 …
     bool brushTextureDirty;
     bool brushUniformsDirty;
-    bool simpleShaderMatrixUniformDirty;
-    bool shaderMatrixUniformDirty;
     bool opacityUniformDirty;
 …
     QSet<QVectorPath::CacheEntry *> pathCaches;
     QVector<GLuint> unusedVBOSToClean;
+    const GLfloat *vertexAttribPointers[3];
 };
+void QGL2PaintEngineExPrivate::setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer)
+{
+    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);
+}
 QT_END_NAMESPACE

trunk/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/opengl.pro

-              r561
+              r651
                 gl2paintengineex/qglengineshadersource_p.h \
                 gl2paintengineex/qglcustomshaderstage_p.h \
+                gl2paintengineex/qtriangulatingstroker_p.h
+                gl2paintengineex/qtriangulatingstroker_p.h \
+                gl2paintengineex/qtextureglyphcache_gl_p.h
     SOURCES +=  qglshaderprogram.cpp \
 …
                 gl2paintengineex/qpaintengineex_opengl2.cpp \
                 gl2paintengineex/qglcustomshaderstage.cpp \
+                gl2paintengineex/qtriangulatingstroker.cpp
+                gl2paintengineex/qtriangulatingstroker.cpp \
+                gl2paintengineex/qtextureglyphcache_gl.cpp
+}

trunk/src/opengl/qgl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
-QGLExtensions::Extensions QGLExtensions::glExtensions = 0;
-bool QGLExtensions::nvidiaFboNeedsFinish = false;
 Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
 QGLSignalProxy *QGLSignalProxy::instance()
 …
         static bool mac_x1600_check_done = false;
         if (!mac_x1600_check_done) {
+            QGLWidget *tmp = 0;
+            if (!QGLContext::currentContext()) {
+                tmp = new QGLWidget();
+                tmp->makeCurrent();
+            }
+            QGLTemporaryContext *tmp = 0;
+            if (!QGLContext::currentContext())
+                tmp = new QGLTemporaryContext();
             if (strstr((char *) glGetString(GL_RENDERER), "X1600"))
                 engineType = QPaintEngine::OpenGL;
 …
             // use GL 2.0.
             if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0)
                 && (QGLExtensions::glExtensions & QGLExtensions::FragmentShader)
+                && (QGLExtensions::glExtensions() & QGLExtensions::FragmentShader)
                 && qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty())
                 engineType = QPaintEngine::OpenGL2;
 …
     static OpenGLVersionFlags defaultVersionFlags = OpenGL_Version_None;
     QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
     QGLWidget *dummy = 0;
+    QGLTemporaryContext *tmpContext = 0;
     if (currentCtx && currentCtx->d_func()->version_flags_cached)
 …
             if (!hasOpenGL())
                 return defaultVersionFlags;
+            dummy = new QGLWidget;
+            dummy->makeCurrent(); // glGetString() needs a current context
+            tmpContext = new QGLTemporaryContext;
             cachedDefault = true;
+        }
 …
         currentCtx->d_func()->version_flags = versionFlags;
+    }
     if (dummy) {
+    if (tmpContext) {
         defaultVersionFlags = versionFlags;
         delete dummy;
+        delete tmpContext;
+    }
 …
+}
+const QGLContext *qt_gl_transfer_context(const QGLContext *ctx)
+{
+    if (!ctx)
+        return 0;
+    QList<const QGLContext *> shares
+        (QGLContextPrivate::contextGroup(ctx)->shares());
+    if (shares.size() >= 2)
+        return (ctx == shares.at(0)) ? shares.at(1) : shares.at(0);
+    else
+        return 0;
+}
 QGLContextPrivate::~QGLContextPrivate()
+{
 …
     version_flags_cached = false;
     version_flags = QGLFormat::OpenGL_Version_None;
+    extension_flags_cached = false;
+    extension_flags = 0;
     current_fbo = 0;
     default_fbo = 0;
     active_engine = 0;
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
+        vertexAttributeArraysEnabledState[i] = false;
+}
 …
 QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha)
+{
     QImage img(size, alpha_format ? QImage::Format_ARGB32 : QImage::Format_RGB32);
+    QImage img(size, alpha_format ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
     int w = size.width();
     int h = size.height();
 …
     qt_gl_texture_cache = this;
+    QImagePixmapCleanupHooks::instance()->addPixmapModificationHook(cleanupTextures);
+#ifdef Q_WS_X11
+    QImagePixmapCleanupHooks::instance()->addPixmapDestructionHook(cleanupPixmapSurfaces);
+#endif
+    QImagePixmapCleanupHooks::instance()->addPixmapDataModificationHook(cleanupTextures);
+    QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(cleanupBeforePixmapDestruction);
     QImagePixmapCleanupHooks::instance()->addImageHook(imageCleanupHook);
+}
 …
     qt_gl_texture_cache = 0;
+    QImagePixmapCleanupHooks::instance()->removePixmapModificationHook(cleanupTextures);
+#ifdef Q_WS_X11
+    QImagePixmapCleanupHooks::instance()->removePixmapDestructionHook(cleanupPixmapSurfaces);
+#endif
+    QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTextures);
+    QImagePixmapCleanupHooks::instance()->removePixmapDataDestructionHook(cleanupBeforePixmapDestruction);
     QImagePixmapCleanupHooks::instance()->removeImageHook(imageCleanupHook);
+}
 …
 void QGLTextureCache::cleanupTextures(QPixmap* pixmap)
+void QGLTextureCache::cleanupTextures(QPixmapData* pmd)
+{
     // ### remove when the GL texture cache becomes thread-safe
     if (qApp->thread() == QThread::currentThread()) {
         const qint64 cacheKey = pixmap->cacheKey();
+        const qint64 cacheKey = pmd->cacheKey();
         QGLTexture *texture = instance()->getTexture(cacheKey);
         if (texture && texture->options & QGLContext::MemoryManagedBindOption)
 …
+}
+void QGLTextureCache::cleanupBeforePixmapDestruction(QPixmapData* pmd)
+{
+    // Remove any bound textures first:
+    cleanupTextures(pmd);
+    Q_ASSERT(instance()->getTexture(pmd->cacheKey()) == 0);
 #if defined(Q_WS_X11)
+void QGLTextureCache::cleanupPixmapSurfaces(QPixmap* pixmap)
+{
+    // Remove any bound textures first:
+    cleanupTextures(pixmap);
+    QPixmapData *pd = pixmap->data_ptr().data();
+    if (pd->classId() == QPixmapData::X11Class) {
+        Q_ASSERT(pd->ref == 1); // Make sure reference counting isn't broken
+        QGLContextPrivate::destroyGlSurfaceForPixmap(pd);
+    }
+}
+#endif
+    if (pmd->classId() == QPixmapData::X11Class) {
+        Q_ASSERT(pmd->ref == 0); // Make sure reference counting isn't broken
+        QGLContextPrivate::destroyGlSurfaceForPixmap(pmd);
+    }
+#endif
+}
 void QGLTextureCache::deleteIfEmpty()
 …
 #endif
-Q_GLOBAL_STATIC(QGLShareRegister, _qgl_share_reg)
-Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg()
+{
-    return _qgl_share_reg();
+}
 /*!
     \class QGLContext
 …
+{
+}
+#define ctx q_ptr
+void QGLContextPrivate::setVertexAttribArrayEnabled(int arrayIndex, bool enabled)
+{
+    Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
+    Q_ASSERT(glEnableVertexAttribArray);
+    if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
+        glDisableVertexAttribArray(arrayIndex);
+    if (!vertexAttributeArraysEnabledState[arrayIndex] && enabled)
+        glEnableVertexAttribArray(arrayIndex);
+    vertexAttributeArraysEnabledState[arrayIndex] = enabled;
+}
+void QGLContextPrivate::syncGlState()
+{
+    Q_ASSERT(glEnableVertexAttribArray);
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
+        if (vertexAttributeArraysEnabledState[i])
+            glEnableVertexAttribArray(i);
+        else
+            glDisableVertexAttribArray(i);
+    }
+}
+#undef ctx
 /*!
 …
     QImage img = image;
     if (!(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures)
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures)
         && !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0)
         && (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
 …
 #endif
     if (glFormat.directRendering()
         && (QGLExtensions::glExtensions & QGLExtensions::GenerateMipmap)
+        && (QGLExtensions::glExtensions() & QGLExtensions::GenerateMipmap)
         && target == GL_TEXTURE_2D
         && (options & QGLContext::MipmapBindOption))
 …
     GLenum externalFormat;
     GLuint pixel_type;
     if (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) {
+    if (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) {
         externalFormat = GL_BGRA;
+        pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2)
+            pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        else
+            pixel_type = GL_UNSIGNED_BYTE;
     } else {
         externalFormat = GL_RGBA;
 …
+    }
 #ifdef QT_OPENGL_ES
+    // OpenGL/ES requires that the internal and external formats be identical.
+    // This is typically used to convert GL_RGBA into GL_BGRA.
+    // Also, we need to use GL_UNSIGNED_BYTE when the format is GL_BGRA.
+    // OpenGL/ES requires that the internal and external formats be
+    // identical.
     internalFormat = externalFormat;
-    if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV)
-        pixel_type = GL_UNSIGNED_BYTE;
 #endif
 #ifdef QGL_BIND_TEXTURE_DEBUG
 …
+    }
     if (d->sharing)  // ok, we managed to share
         qgl_share_reg()->addShare(this, shareContext);
+        QGLContextGroup::addShare(this, shareContext);
     return d->valid;
+}
 …
    text is drawn.
+   \note This function can only be used inside a
+   QPainter::beginNativePainting()/QPainter::endNativePainting() block
+   if the default OpenGL paint engine is QPaintEngine::OpenGL. To make
+   QPaintEngine::OpenGL the default GL engine, call
+   QGL::setPreferredPaintEngine(QPaintEngine::OpenGL) before the
+   QApplication constructor.
    \l{Overpainting Example}{Overpaint} with QPainter::drawText() instead.
 */
 …
 #endif // QT3_SUPPORT
+void QGLExtensions::init_extensions()
+/*
+    Returns the GL extensions for the current context.
+*/
+QGLExtensions::Extensions QGLExtensions::currentContextExtensions()
+{
     QGLExtensionMatcher extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)));
+    Extensions glExtensions;
     if (extensions.match("GL_ARB_texture_rectangle"))
 …
     if (extensions.match("GL_EXT_bgra"))
         glExtensions |= BGRATextureFormat;
+    return glExtensions;
+}
+/*
+    Returns the GL extensions for the current QGLContext. If there is no
+    current QGLContext, a default context will be created and the extensions
+    for that context will be returned instead.
+*/
+QGLExtensions::Extensions QGLExtensions::glExtensions()
+{
+    QGLTemporaryContext *tmpContext = 0;
+    static bool cachedDefault = false;
+    static Extensions defaultExtensions = 0;
+    QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
+    if (currentCtx && currentCtx->d_func()->extension_flags_cached)
+        return currentCtx->d_func()->extension_flags;
+    if (!currentCtx) {
+        if (cachedDefault) {
+            return defaultExtensions;
+        } else {
+            tmpContext = new QGLTemporaryContext;
+            cachedDefault = true;
+        }
+    }
+    Extensions extensionFlags = currentContextExtensions();
+    if (currentCtx) {
+        currentCtx->d_func()->extension_flags_cached = true;
+        currentCtx->d_func()->extension_flags = extensionFlags;
+    } else {
+        defaultExtensions = extensionFlags;
+    }
+    if (tmpContext)
+        delete tmpContext;
+    return extensionFlags;
+}
 …
     glDevice.setWidget(q);
-    QGLExtensions::init();
     glcx = 0;
     autoSwap = true;
 …
     if (!glcx)
         glcx = new QGLContext(QGLFormat::defaultFormat(), q);
-    q->setAttribute(Qt::WA_NoSystemBackground);
+}
 …
 #endif
 void QGLShareRegister::addShare(const QGLContext *context, const QGLContext *share) {
+void QGLContextGroup::addShare(const QGLContext *context, const QGLContext *share) {
     Q_ASSERT(context && share);
     if (context->d_ptr->group == share->d_ptr->group)
 …
+}
+QList<const QGLContext *> QGLShareRegister::shares(const QGLContext *context) {
+    return context->d_ptr->group->m_shares;
+}
+void QGLShareRegister::removeShare(const QGLContext *context) {
+void QGLContextGroup::removeShare(const QGLContext *context) {
     // Remove the context from the group.
     QGLContextGroup *group = context->d_ptr->group;
 …
 #if !defined(QT_OPENGL_ES)
     if (!glCompressedTexImage2D) {
         if (!(QGLExtensions::glExtensions & QGLExtensions::TextureCompression)) {
+        if (!(QGLExtensions::glExtensions() & QGLExtensions::TextureCompression)) {
             qWarning("QGLContext::bindTexture(): The GL implementation does "
                      "not support texture compression extensions.");
 …
     // Bail out if the necessary extension is not present.
     if (!(QGLExtensions::glExtensions & QGLExtensions::DDSTextureCompression)) {
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::DDSTextureCompression)) {
         qWarning("QGLContext::bindTexture(): DDS texture compression is not supported.");
         return QSize();
 …
     // Bail out if the necessary extension is not present.
     if (textureFormat == GL_ETC1_RGB8_OES) {
         if (!(QGLExtensions::glExtensions &
+        if (!(QGLExtensions::glExtensions() &
                     QGLExtensions::ETC1TextureCompression)) {
             qWarning("QGLContext::bindTexture(): ETC1 texture compression is not supported.");
 …
+        }
     } else {
         if (!(QGLExtensions::glExtensions &
+        if (!(QGLExtensions::glExtensions() &
                     QGLExtensions::PVRTCTextureCompression)) {
             qWarning("QGLContext::bindTexture(): PVRTC texture compression is not supported.");

trunk/src/opengl/qgl.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     friend class QGL2PaintEngineEx;
     friend class QGL2PaintEngineExPrivate;
+    friend class QGLEngineShaderManager;
     friend class QGLWindowSurface;
     friend class QGLPixmapData;
     friend class QGLPixmapFilterBase;
     friend class QGLTextureGlyphCache;
     friend class QGLShareRegister;
+    friend class QGLContextGroup;
     friend class QGLSharedResourceGuard;
     friend class QGLPixmapBlurFilter;
+    friend class QGLExtensions;
     friend QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags();
 #ifdef Q_WS_MAC

trunk/src/opengl/qgl_cl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgl_egl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     d->transpColor = QColor();
     d->initDone = false;
     qgl_share_reg()->removeShare(this);
+    QGLContextGroup::removeShare(this);
+}

trunk/src/opengl/qgl_egl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgl_mac.mm

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 extern QRegion qt_mac_convert_mac_region(RgnHandle); //qregion_mac.cpp
 extern void qt_mac_to_pascal_string(QString s, Str255 str, TextEncoding encoding=0, int len=-1);  //qglobal.cpp
+/*
+    QGLTemporaryContext implementation
+*/
+class QGLTemporaryContextPrivate
+{
+public:
+#ifndef QT_MAC_USE_COCOA
+    AGLContext ctx;
+#else
+    NSOpenGLContext *ctx;
+#endif
+};
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->ctx = 0;
+#ifndef QT_MAC_USE_COCOA
+    GLint attribs[] = {AGL_RGBA, AGL_NONE};
+    AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);
+    if (!fmt) {
+        qDebug("QGLTemporaryContext: Couldn't find any RGB visuals");
+        return;
+    }
+    d->ctx = aglCreateContext(fmt, 0);
+    if (!d->ctx)
+        qDebug("QGLTemporaryContext: Unable to create context");
+    else
+        aglSetCurrentContext(d->ctx);
+    aglDestroyPixelFormat(fmt);
+#else
+    QMacCocoaAutoReleasePool pool;
+    NSOpenGLPixelFormatAttribute attribs[] = { 0 };
+    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
+    if (!fmt) {
+        qWarning("QGLTemporaryContext: Cannot find any visuals");
+        return;
+    }
+    d->ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];
+    if (!d->ctx)
+        qWarning("QGLTemporaryContext: Cannot create context");
+    else
+        [d->ctx makeCurrentContext];
+    [fmt release];
+#endif
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->ctx) {
+#ifndef QT_MAC_USE_COCOA
+        aglSetCurrentContext(0);
+        aglDestroyContext(d->ctx);
+#else
+        [NSOpenGLContext clearCurrentContext];
+        [d->ctx release];
+#endif
+    }
+}
 bool QGLFormat::hasOpenGL()
 …
     d->transpColor = QColor();
     d->initDone = false;
     qgl_share_reg()->removeShare(this);
+    QGLContextGroup::removeShare(this);
+}
 …
+        }
     } else if (d->paintDevice->devType() == QInternal::Pixmap) {
+        QPixmap *pm = (QPixmap *)d->paintDevice;
+        PixMapHandle mac_pm = GetGWorldPixMap((GWorldPtr)pm->macQDHandle());
+        aglSetOffScreen((AGLContext)d->cx, pm->width(), pm->height(),
+                GetPixRowBytes(mac_pm), GetPixBaseAddr(mac_pm));
+        QPixmap *pm = reinterpret_cast<QPixmap *>(d->paintDevice);
+        unsigned long qdformat = k32ARGBPixelFormat;
+        if (QSysInfo::ByteOrder == QSysInfo::LittleEndian)
+            qdformat = k32BGRAPixelFormat;
+        Rect rect;
+        SetRect(&rect, 0, 0, pm->width(), pm->height());
+        GWorldPtr gworld;
+        NewGWorldFromPtr(&gworld, qdformat, &rect, 0, 0, 0,
+                         reinterpret_cast<char *>(qt_mac_pixmap_get_base(pm)),
+                         qt_mac_pixmap_get_bytes_per_line(pm));
+        PixMapHandle pixmapHandle = GetGWorldPixMap(gworld);
+        aglSetOffScreen(reinterpret_cast<AGLContext>(d->cx), pm->width(), pm->height(),
+                        GetPixRowBytes(pixmapHandle), GetPixBaseAddr(pixmapHandle));
     } else {
         qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-#ifndef QT_MAC_USE_COCOA
-    GLint attribs[] = { AGL_RGBA, AGL_NONE };
-    AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);
-    if (!fmt) {
-        qDebug("QGLExtensions: Couldn't find any RGB visuals");
-        return;
+    }
-    AGLContext ctx = aglCreateContext(fmt, 0);
-    if (!ctx) {
-        qDebug("QGLExtensions: Unable to create context");
-    } else {
-        aglSetCurrentContext(ctx);
-        init_extensions();
-        aglSetCurrentContext(0);
-        aglDestroyContext(ctx);
+    }
-    aglDestroyPixelFormat(fmt);
-#else
-    QMacCocoaAutoReleasePool pool;
-    NSOpenGLPixelFormatAttribute attribs[] = { 0 };
-    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
-    if (!fmt) {
-        qWarning("QGLExtensions: Cannot find any visuals");
-        return;
+    }
-    NSOpenGLContext *ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];
-    if (!ctx) {
-        qWarning("QGLExtensions: Cannot create context");
-    } else {
-        [ctx makeCurrentContext];
-        init_extensions();
-        [NSOpenGLContext clearCurrentContext];
-        [ctx release];
+    }
-    [fmt release];
-#endif
+}
 #endif

trunk/src/opengl/qgl_p.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 // QGLContextPrivate has the responsibility of creating context groups.
 // QGLContextPrivate and QGLShareRegister will both maintain the reference counter and destroy
+// QGLContextPrivate maintains the reference counter and destroys
 // context groups when needed.
-// QGLShareRegister has the responsibility of keeping the context pointer up to date.
 class QGLContextGroup
+{
 …
     const QGLContext *context() const {return m_context;}
     bool isSharing() const { return m_shares.size() >= 2; }
+    QList<const QGLContext *> shares() const { return m_shares; }
     void addGuard(QGLSharedResourceGuard *guard);
     void removeGuard(QGLSharedResourceGuard *guard);
+    static void addShare(const QGLContext *context, const QGLContext *share);
+    static void removeShare(const QGLContext *context);
 private:
     QGLContextGroup(const QGLContext *context) : m_context(context), m_guards(0), m_refs(1) { }
 …
     void cleanupResources(const QGLContext *ctx);
-    friend class QGLShareRegister;
     friend class QGLContext;
     friend class QGLContextPrivate;
 …
 };
+class QGLTexture;
+class QGLContextPrivate
+{
+    Q_DECLARE_PUBLIC(QGLContext)
+public:
+    explicit QGLContextPrivate(QGLContext *context) : internal_context(false), q_ptr(context) {group = new QGLContextGroup(context);}
+    ~QGLContextPrivate();
+    QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format,
+                            QGLContext::BindOptions options);
+    QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format, const qint64 key,
+                            QGLContext::BindOptions options);
+    QGLTexture *bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
+                            QGLContext::BindOptions options);
+    QGLTexture *textureCacheLookup(const qint64 key, GLenum target);
+    void init(QPaintDevice *dev, const QGLFormat &format);
+    QImage convertToGLFormat(const QImage &image, bool force_premul, GLenum texture_format);
+    int maxTextureSize();
+    void cleanup();
+#if defined(Q_WS_WIN)
+    HGLRC rc;
+    HDC dc;
+    WId        win;
+    int pixelFormatId;
+    QGLCmap* cmap;
+    HBITMAP hbitmap;
+    HDC hbitmap_hdc;
+#endif
+#if defined(QT_OPENGL_ES)
+    QEglContext *eglContext;
+    EGLSurface eglSurface;
+    void destroyEglSurfaceForDevice();
+#elif defined(Q_WS_X11) || defined(Q_WS_MAC)
+    void* cx;
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC)
+    void* vi;
+#endif
+#if defined(Q_WS_X11)
+    void* pbuf;
+    quint32 gpm;
+    int screen;
+    QHash<QPixmapData*, QPixmap> boundPixmaps;
+    QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key,
+                                            QGLContext::BindOptions options);
+    static void destroyGlSurfaceForPixmap(QPixmapData*);
+    static void unbindPixmapFromTexture(QPixmapData*);
+#endif
+#if defined(Q_WS_MAC)
+    bool update;
+    void *tryFormat(const QGLFormat &format);
+    void clearDrawable();
+#endif
+    QGLFormat glFormat;
+    QGLFormat reqFormat;
+    GLuint fbo;
+    uint valid : 1;
+    uint sharing : 1;
+    uint initDone : 1;
+    uint crWin : 1;
+    uint internal_context : 1;
+    uint version_flags_cached : 1;
+    QPaintDevice *paintDevice;
+    QColor transpColor;
+    QGLContext *q_ptr;
+    QGLFormat::OpenGLVersionFlags version_flags;
+    QGLContextGroup *group;
+    GLint max_texture_size;
+    GLuint current_fbo;
+    GLuint default_fbo;
+    QPaintEngine *active_engine;
+    static inline QGLContextGroup *contextGroup(const QGLContext *ctx) { return ctx->d_ptr->group; }
+#ifdef Q_WS_WIN
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *ctx) { return ctx->d_ptr->group->extensionFuncs(); }
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+    static QGLExtensionFuncs qt_extensionFuncs;
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *) { return qt_extensionFuncs; }
+#endif
+    static void setCurrentContext(QGLContext *context);
+};
+// ### make QGLContext a QObject in 5.0 and remove the proxy stuff
+class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
+{
+    Q_OBJECT
+public:
+    QGLSignalProxy() : QObject() {}
+    void emitAboutToDestroyContext(const QGLContext *context) {
+        emit aboutToDestroyContext(context);
+    }
+    static QGLSignalProxy *instance();
+Q_SIGNALS:
+    void aboutToDestroyContext(const QGLContext *context);
+};
+// Get the context that resources for "ctx" will transfer to once
+// "ctx" is destroyed.  Returns null if nothing is sharing with ctx.
+Q_OPENGL_EXPORT const QGLContext *qt_gl_transfer_context(const QGLContext *);
 // GL extension definitions
 …
     Q_DECLARE_FLAGS(Extensions, Extension)
+    static Extensions glExtensions;
+    static bool nvidiaFboNeedsFinish;
+    static void init(); // sys dependent
+    static void init_extensions(); // general: called by init()
+    static Extensions glExtensions();
+private:
+    static Extensions currentContextExtensions();
+};
+/*
+    QGLTemporaryContext - the main objective of this class is to have a way of
+    creating a GL context and making it current, without going via QGLWidget
+    and friends. At certain points during GL initialization we need a current
+    context in order decide what GL features are available, and to resolve GL
+    extensions. Having a light-weight way of creating such a context saves
+    initial application startup time, and it doesn't wind up creating recursive
+    conflicts.
+    The class currently uses a private d pointer to hide the platform specific
+    types. This could possibly been done inline with #ifdef'ery, but it causes
+    major headaches on e.g. X11 due to namespace pollution.
+*/
+class QGLTemporaryContextPrivate;
+class QGLTemporaryContext {
+public:
+    QGLTemporaryContext(bool directRendering = true, QWidget *parent = 0);
+    ~QGLTemporaryContext();
+private:
+    QScopedPointer<QGLTemporaryContextPrivate> d;
+};
+class QGLTexture;
+// This probably needs to grow to GL_MAX_VERTEX_ATTRIBS, but 3 is ok for now as that's
+// all the GL2 engine uses:
+#define QT_GL_VERTEX_ARRAY_TRACKED_COUNT 3
+class QGLContextPrivate
+{
+    Q_DECLARE_PUBLIC(QGLContext)
+public:
+    explicit QGLContextPrivate(QGLContext *context) : internal_context(false), q_ptr(context) {group = new QGLContextGroup(context);}
+    ~QGLContextPrivate();
+    QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format,
+                            QGLContext::BindOptions options);
+    QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format, const qint64 key,
+                            QGLContext::BindOptions options);
+    QGLTexture *bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
+                            QGLContext::BindOptions options);
+    QGLTexture *textureCacheLookup(const qint64 key, GLenum target);
+    void init(QPaintDevice *dev, const QGLFormat &format);
+    QImage convertToGLFormat(const QImage &image, bool force_premul, GLenum texture_format);
+    int maxTextureSize();
+    void cleanup();
+    void setVertexAttribArrayEnabled(int arrayIndex, bool enabled = true);
+    void syncGlState(); // Makes sure the GL context's state is what we think it is
+#if defined(Q_WS_WIN)
+    HGLRC rc;
+    HDC dc;
+    WId        win;
+    int pixelFormatId;
+    QGLCmap* cmap;
+    HBITMAP hbitmap;
+    HDC hbitmap_hdc;
+#endif
+#if defined(QT_OPENGL_ES)
+    QEglContext *eglContext;
+    EGLSurface eglSurface;
+    void destroyEglSurfaceForDevice();
+#elif defined(Q_WS_X11) || defined(Q_WS_MAC)
+    void* cx;
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC)
+    void* vi;
+#endif
+#if defined(Q_WS_X11)
+    void* pbuf;
+    quint32 gpm;
+    int screen;
+    QHash<QPixmapData*, QPixmap> boundPixmaps;
+    QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key,
+                                            QGLContext::BindOptions options);
+    static void destroyGlSurfaceForPixmap(QPixmapData*);
+    static void unbindPixmapFromTexture(QPixmapData*);
+#endif
+#if defined(Q_WS_MAC)
+    bool update;
+    void *tryFormat(const QGLFormat &format);
+    void clearDrawable();
+#endif
+    QGLFormat glFormat;
+    QGLFormat reqFormat;
+    GLuint fbo;
+    uint valid : 1;
+    uint sharing : 1;
+    uint initDone : 1;
+    uint crWin : 1;
+    uint internal_context : 1;
+    uint version_flags_cached : 1;
+    uint extension_flags_cached : 1;
+    QPaintDevice *paintDevice;
+    QColor transpColor;
+    QGLContext *q_ptr;
+    QGLFormat::OpenGLVersionFlags version_flags;
+    QGLExtensions::Extensions extension_flags;
+    QGLContextGroup *group;
+    GLint max_texture_size;
+    GLuint current_fbo;
+    GLuint default_fbo;
+    QPaintEngine *active_engine;
+    bool vertexAttributeArraysEnabledState[QT_GL_VERTEX_ARRAY_TRACKED_COUNT];
+    static inline QGLContextGroup *contextGroup(const QGLContext *ctx) { return ctx->d_ptr->group; }
+#ifdef Q_WS_WIN
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *ctx) { return ctx->d_ptr->group->extensionFuncs(); }
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+    static QGLExtensionFuncs qt_extensionFuncs;
+    static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *) { return qt_extensionFuncs; }
+#endif
+    static void setCurrentContext(QGLContext *context);
+};
+// ### make QGLContext a QObject in 5.0 and remove the proxy stuff
+class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
+{
+    Q_OBJECT
+public:
+    QGLSignalProxy() : QObject() {}
+    void emitAboutToDestroyContext(const QGLContext *context) {
+        emit aboutToDestroyContext(context);
+    }
+    static QGLSignalProxy *instance();
+Q_SIGNALS:
+    void aboutToDestroyContext(const QGLContext *context);
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGLExtensions::Extensions)
-class Q_OPENGL_EXPORT QGLShareRegister
+{
-public:
-    QGLShareRegister() {}
-    ~QGLShareRegister() {}
-    void addShare(const QGLContext *context, const QGLContext *share);
-    QList<const QGLContext *> shares(const QGLContext *context);
-    void removeShare(const QGLContext *context);
-};
-extern Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg();
 // Temporarily make a context current if not already current or
 …
 };
 class QGLTextureCache {
+class Q_AUTOTEST_EXPORT QGLTextureCache {
 public:
     QGLTextureCache();
 …
     static void deleteIfEmpty();
     static void imageCleanupHook(qint64 cacheKey);
+    static void cleanupTextures(QPixmap* pixmap);
+#ifdef Q_WS_X11
+    // X11 needs to catch pixmap data destruction to delete EGL/GLX pixmap surfaces
+    static void cleanupPixmapSurfaces(QPixmap* pixmap);
+#endif
+    static void cleanupTextures(QPixmapData* pixmap);
+    static void cleanupBeforePixmapDestruction(QPixmapData* pixmap);
 private:
 …
 inline GLenum qt_gl_preferredTextureFormat()
+{
     return (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
+    return (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
         ? GL_BGRA : GL_RGBA;
+}
 …
     return GL_TEXTURE_2D;
 #else
     return (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    return (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
            && !qt_gl_preferGL2Engine()
            ? GL_TEXTURE_RECTANGLE_NV
 …
 // This class can be used to match GL extensions with doing any mallocs. The
+// This class can be used to match GL extensions without doing any mallocs. The
 // class assumes that the GL extension string ends with a space character,
 // which it should do on all conformant platforms. Create the object and pass

trunk/src/opengl/qgl_qws.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     else
         return 0;
+}
+/*
+    QGLTemporaryContext implementation
+*/
+class QGLTemporaryContextPrivate
+{
+public:
+    QGLWidget *widget;
+};
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->widget = new QGLWidget;
+    d->widget->makeCurrent();
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    delete d->widget;
+}
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-    // We need a context current to initialize the extensions,
-    // but getting a valid EGLNativeWindowType this early can be
-    // problematic under QWS.  So use a pbuffer instead.
-    //
-    // Unfortunately OpenGL/ES 2.0 systems don't normally
-    // support pbuffers, so we have no choice but to try
-    // our luck with a window on those systems.
-#if defined(QT_OPENGL_ES_2)
-    QGLWidget tmpWidget;
-    tmpWidget.makeCurrent();
-    init_extensions();
-    tmpWidget.doneCurrent();
-#else
-    QGLPixelBuffer pbuffer(16, 16);
-    pbuffer.makeCurrent();
-    init_extensions();
-    pbuffer.doneCurrent();
-#endif
+}
 QT_END_NAMESPACE

trunk/src/opengl/qgl_win.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QVarLengthArray<int> iValues(40);
     int i = 0;
     bool has_sample_buffers = QGLExtensions::glExtensions & QGLExtensions::SampleBuffers;
+    bool has_sample_buffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;
     iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB; // 0
 …
 /*
+   Creates a temporary GL context and makes it current
+   - cleans up when the object is destructed.
+    QGLTemporaryContext implementation
 */
 Q_GUI_EXPORT const QString qt_getRegisteredWndClass();
 class QGLTempContext
+class QGLTemporaryContextPrivate
+{
 public:
-    QGLTempContext(bool directRendering, QWidget *parent = 0)
+    {
-        QString windowClassName = qt_getRegisteredWndClass();
-        if (parent && !parent->internalWinId())
-            parent = parent->nativeParentWidget();
-        dmy_id = CreateWindow((const wchar_t *)windowClassName.utf16(),
-, 0, 0, 0, 1, 1,
-                              parent ? parent->winId() : 0, 0, qWinAppInst(), 0);
-        dmy_pdc = GetDC(dmy_id);
-        PIXELFORMATDESCRIPTOR dmy_pfd;
-        memset(&dmy_pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
-        dmy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
-        dmy_pfd.nVersion = 1;
-        dmy_pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
-        dmy_pfd.iPixelType = PFD_TYPE_RGBA;
-        if (!directRendering)
-            dmy_pfd.dwFlags |= PFD_GENERIC_FORMAT;
-        int dmy_pf = ChoosePixelFormat(dmy_pdc, &dmy_pfd);
-        SetPixelFormat(dmy_pdc, dmy_pf, &dmy_pfd);
-        dmy_rc = wglCreateContext(dmy_pdc);
-        old_dc = wglGetCurrentDC();
-        old_context = wglGetCurrentContext();
-        wglMakeCurrent(dmy_pdc, dmy_rc);
+    }
-    ~QGLTempContext() {
-        wglMakeCurrent(dmy_pdc, 0);
-        wglDeleteContext(dmy_rc);
-        ReleaseDC(dmy_id, dmy_pdc);
-        DestroyWindow(dmy_id);
-        if (old_dc && old_context)
-            wglMakeCurrent(old_dc, old_context);
+    }
     HDC dmy_pdc;
     HGLRC dmy_rc;
 …
     WId dmy_id;
 };
+QGLTemporaryContext::QGLTemporaryContext(bool directRendering, QWidget *parent)
+    : d(new QGLTemporaryContextPrivate)
+{
+    QString windowClassName = qt_getRegisteredWndClass();
+    if (parent && !parent->internalWinId())
+        parent = parent->nativeParentWidget();
+    d->dmy_id = CreateWindow((const wchar_t *)windowClassName.utf16(),
+, 0, 0, 0, 1, 1,
+                             parent ? parent->winId() : 0, 0, qWinAppInst(), 0);
+    d->dmy_pdc = GetDC(d->dmy_id);
+    PIXELFORMATDESCRIPTOR dmy_pfd;
+    memset(&dmy_pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
+    dmy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
+    dmy_pfd.nVersion = 1;
+    dmy_pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
+    dmy_pfd.iPixelType = PFD_TYPE_RGBA;
+    if (!directRendering)
+        dmy_pfd.dwFlags |= PFD_GENERIC_FORMAT;
+    int dmy_pf = ChoosePixelFormat(d->dmy_pdc, &dmy_pfd);
+    SetPixelFormat(d->dmy_pdc, dmy_pf, &dmy_pfd);
+    d->dmy_rc = wglCreateContext(d->dmy_pdc);
+    d->old_dc = wglGetCurrentDC();
+    d->old_context = wglGetCurrentContext();
+    wglMakeCurrent(d->dmy_pdc, d->dmy_rc);
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    wglMakeCurrent(d->dmy_pdc, 0);
+    wglDeleteContext(d->dmy_rc);
+    ReleaseDC(d->dmy_id, d->dmy_pdc);
+    DestroyWindow(d->dmy_id);
+    if (d->old_dc && d->old_context)
+        wglMakeCurrent(d->old_dc, d->old_context);
+}
 bool QGLContext::chooseContext(const QGLContext* shareContext)
 …
+    }
     // NB! the QGLTempContext object is needed for the
+    // NB! the QGLTemporaryContext object is needed for the
     // wglGetProcAddress() calls to succeed and are absolutely
     // necessary - don't remove!
     QGLTempContext tmp_ctx(d->glFormat.directRendering(), widget);
+    QGLTemporaryContext tmp_ctx(d->glFormat.directRendering(), widget);
     if (!myDc) {
 …
+        }
         int si = 0;
         bool trySampleBuffers = QGLExtensions::glExtensions & QGLExtensions::SampleBuffers;
+        bool trySampleBuffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;
         if (trySampleBuffers && d->glFormat.sampleBuffers()) {
             iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;
 …
     d->cmap = 0;
     d->initDone = false;
     qgl_share_reg()->removeShare(this);
+    QGLContextGroup::removeShare(this);
+}
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-    QGLTempContext temp_ctx(QGLFormat::defaultFormat().directRendering());
-    init_extensions();
+}
 QT_END_NAMESPACE

trunk/src/opengl/qgl_wince.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qcolor.h>
+/*
+    QGLTemporaryContext implementation
+*/
+class QGLTemporaryContextPrivate
+{
+public:
+    QGLWidget *widget;
+};
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->widget = new QGLWidget;
+    d->widget->makeCurrent();
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    delete d->widget;
+}
 /*****************************************************************************
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-    // We need a context current to initialize the extensions.
-    QGLWidget tmpWidget;
-    tmpWidget.makeCurrent();
-    init_extensions();
-    tmpWidget.doneCurrent();
+}
 QT_END_NAMESPACE

trunk/src/opengl/qgl_x11.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     bool triedSample = false;
     if (fmt.sampleBuffers())
         fmt.setSampleBuffers(QGLExtensions::glExtensions & QGLExtensions::SampleBuffers);
+        fmt.setSampleBuffers(QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers);
     while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) {
         if (!fmt.rgba() && bufDepths[i] > 1) {
 …
     d->transpColor = QColor();
     d->initDone = false;
     qgl_share_reg()->removeShare(this);
+    QGLContextGroup::removeShare(this);
+}
 …
+}
+/*
+    QGLTemporaryContext implementation
+*/
+class QGLTemporaryContextPrivate {
+public:
+    bool initialized;
+    Window drawable;
+    GLXContext context;
+    GLXDrawable oldDrawable;
+    GLXContext oldContext;
+};
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->initialized = false;
+    d->oldDrawable = 0;
+    d->oldContext = 0;
+    int screen = 0;
+    int attribs[] = {GLX_RGBA, XNone};
+    XVisualInfo *vi = glXChooseVisual(X11->display, screen, attribs);
+    if (!vi) {
+        qWarning("QGLTempContext: No GL capable X visuals available.");
+        return;
+    }
+    int useGL;
+    glXGetConfig(X11->display, vi, GLX_USE_GL, &useGL);
+    if (!useGL) {
+        XFree(vi);
+        return;
+    }
+    d->oldDrawable = glXGetCurrentDrawable();
+    d->oldContext = glXGetCurrentContext();
+    XSetWindowAttributes a;
+    a.colormap = qt_gl_choose_cmap(X11->display, vi);
+    d->drawable = XCreateWindow(X11->display, RootWindow(X11->display, screen),
+, 0, 1, 1, 0,
+                                vi->depth, InputOutput, vi->visual,
+                                CWColormap, &a);
+    d->context = glXCreateContext(X11->display, vi, 0, True);
+    if (d->context && glXMakeCurrent(X11->display, d->drawable, d->context)) {
+        d->initialized = true;
+    } else {
+        qWarning("QGLTempContext: Unable to create GL context.");
+        XDestroyWindow(X11->display, d->drawable);
+    }
+    XFree(vi);
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->initialized) {
+        glXMakeCurrent(X11->display, 0, 0);
+        glXDestroyContext(X11->display, d->context);
+        XDestroyWindow(X11->display, d->drawable);
+    }
+    if (d->oldDrawable && d->oldContext)
+        glXMakeCurrent(X11->display, d->oldDrawable, d->oldContext);
+}
 /*****************************************************************************
   QGLOverlayWidget (Internal overlay class for X11)
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-    QGLWidget dmy;
-    dmy.makeCurrent();
-    init_extensions();
-    // nvidia 9x.xx unix drivers contain a bug which requires us to call glFinish before releasing an fbo
-    // to avoid painting artifacts
-    const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
-    const int pos = versionString.indexOf("NVIDIA");
-    if (pos >= 0) {
-        const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
-        nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
+    }
+}
 // Solaris defines glXBindTexImageEXT as part of the GL library
 #if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
 …
         // Check to see if we have NPOT texture support
         if ( !(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures) &&
+        if ( !(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures) &&
              !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
+        {
             return false; // Can't use TFP without NPOT
+        }
         const QX11Info *xinfo = qt_x11Info(paintDevice);
+        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+        Display *display = xinfo ? xinfo->display() : X11->display;
+        int screen = xinfo ? xinfo->screen() : X11->defaultScreen;
+        QGLExtensionMatcher extensions(glXQueryExtensionsString(display, screen));
         if (extensions.match("GLX_EXT_texture_from_pixmap")) {
             glXBindTexImageEXT = (qt_glXBindTexImageEXT) qglx_getProcAddress("glXBindTexImageEXT");

trunk/src/opengl/qgl_x11egl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QT_BEGIN_NAMESPACE
+bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,
+                             const QX11Info &x11Info, bool useArgbVisual);
+/*
+    QGLTemporaryContext implementation
+*/
+class QGLTemporaryContextPrivate
+{
+public:
+    bool initialized;
+    Window window;
+    EGLContext context;
+    EGLSurface surface;
+    EGLDisplay display;
+};
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->initialized = false;
+    d->window = 0;
+    d->context = 0;
+    d->surface = 0;
+    int screen = 0;
+    d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));
+    if (!eglInitialize(d->display, NULL, NULL)) {
+        qWarning("QGLTemporaryContext: Unable to initialize EGL display.");
+        return;
+    }
+    EGLConfig config;
+    int numConfigs = 0;
+    EGLint attribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+#ifdef QT_OPENGL_ES_2
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+#endif
+        EGL_NONE
+    };
+    eglChooseConfig(d->display, attribs, &config, 1, &numConfigs);
+    if (!numConfigs) {
+        qWarning("QGLTemporaryContext: No EGL configurations available.");
+        return;
+    }
+    XVisualInfo visualInfo;
+    XVisualInfo *vi;
+    int numVisuals;
+    EGLint id = 0;
+    eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);
+    if (id == 0) {
+        // EGL_NATIVE_VISUAL_ID is optional and might not be supported
+        // on some implementations - we'll have to do it the hard way
+        QX11Info xinfo;
+        qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);
+    } else {
+        visualInfo.visualid = id;
+    }
+    vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);
+    if (!vi || numVisuals < 1) {
+        qWarning("QGLTemporaryContext: Unable to get X11 visual info id.");
+        return;
+    }
+    d->window = XCreateWindow(X11->display, RootWindow(X11->display, screen),
+, 0, 1, 1, 0,
+                              vi->depth, InputOutput, vi->visual,
+, 0);
+    d->surface = eglCreateWindowSurface(d->display, config, (EGLNativeWindowType) d->window, NULL);
+    if (d->surface == EGL_NO_SURFACE) {
+        qWarning("QGLTemporaryContext: Error creating EGL surface.");
+        XFree(vi);
+        XDestroyWindow(X11->display, d->window);
+        return;
+    }
+    EGLint contextAttribs[] = {
+#ifdef QT_OPENGL_ES_2
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+        EGL_NONE
+    };
+    d->context = eglCreateContext(d->display, config, 0, contextAttribs);
+    if (d->context != EGL_NO_CONTEXT
+        && eglMakeCurrent(d->display, d->surface, d->surface, d->context))
+    {
+        d->initialized = true;
+    } else {
+        qWarning("QGLTemporaryContext: Error creating EGL context.");
+        eglDestroySurface(d->display, d->surface);
+        XDestroyWindow(X11->display, d->window);
+    }
+    XFree(vi);
+}
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->initialized) {
+        eglMakeCurrent(d->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroyContext(d->display, d->context);
+        eglDestroySurface(d->display, d->surface);
+        XDestroyWindow(X11->display, d->window);
+    }
+}
 bool QGLFormat::hasOpenGLOverlays()
+{
 …
     // If EGL does not know the visual ID, so try to select an appropriate one ourselves, first
     // using XRender if we're supposed to have an alpha, then falling back to XGetVisualInfo
 #if !defined(QT_NO_XRENDER)
     if (vi.visualid == 0 && useArgbVisual) {
 …
+}
-void QGLExtensions::init()
+{
-    static bool init_done = false;
-    if (init_done)
-        return;
-    init_done = true;
-    // We need a context current to initialize the extensions.
-    QGLWidget tmpWidget;
-    tmpWidget.makeCurrent();
-    init_extensions();
-    tmpWidget.doneCurrent();
+}
 // Re-creates the EGL surface if the window ID has changed or if force is true
 void QGLWidgetPrivate::recreateEglSurface(bool force)

trunk/src/opengl/qglcolormap.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglcolormap.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglextensions.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglextensions_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglframebufferobject.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     fbo_guard.setContext(ctx);
     bool ext_detected = (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject);
+    bool ext_detected = (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
     if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx)))
         return;
 …
     if (attachment == QGLFramebufferObject::CombinedDepthStencil
         && (QGLExtensions::glExtensions & QGLExtensions::PackedDepthStencil)) {
+        && (QGLExtensions::glExtensions() & QGLExtensions::PackedDepthStencil)) {
         // depth and stencil buffer needs another extension
         glGenRenderbuffers(1, &depth_stencil_buffer);
 …
 bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
+{
+    QGLExtensions::init();
+    return (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject);
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
+}
 …
 bool QGLFramebufferObject::hasOpenGLFramebufferBlit()
+{
+    QGLExtensions::init();
+    return (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit);
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit);
+}
 …
                                            GLenum filter)
+{
     if (!(QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit))
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit))
         return;

trunk/src/opengl/qglframebufferobject.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglframebufferobject_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpaintdevice.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpaintdevice_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixelbuffer.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         qctx->d_func()->sharing = (shareWidget != 0);
         if (shareWidget != 0 && shareWidget->d_func()->glcx) {
             qgl_share_reg()->addShare(qctx, shareWidget->d_func()->glcx);
+            QGLContextGroup::addShare(qctx, shareWidget->d_func()->glcx);
             shareWidget->d_func()->glcx->d_func()->sharing = true;
+        }

trunk/src/opengl/qglpixelbuffer.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixelbuffer_egl.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixelbuffer_mac.mm

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     GLenum target = GL_TEXTURE_2D;
     if ((QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    if ((QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
         && (size.width() != nearest_gl_texture_size(size.width())
             || size.height() != nearest_gl_texture_size(size.height())))
 …
     GLenum target = GL_TEXTURE_2D;
     if ((QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    if ((QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
         && (size.width() != nearest_gl_texture_size(size.width())
             || size.height() != nearest_gl_texture_size(size.height())))

trunk/src/opengl/qglpixelbuffer_p.h

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QGLPixelBufferPrivate(QGLPixelBuffer *q) : q_ptr(q), invalid(true), qctx(0), pbuf(0), ctx(0)
+    {
-        QGLExtensions::init();
 #ifdef Q_WS_WIN
         dc = 0;

trunk/src/opengl/qglpixelbuffer_win.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     if ((f.redBufferSize() > 8 || f.greenBufferSize() > 8
          || f.blueBufferSize() > 8 || f.alphaBufferSize() > 8)
         && (QGLExtensions::glExtensions & QGLExtensions::NVFloatBuffer))
+        && (QGLExtensions::glExtensions() & QGLExtensions::NVFloatBuffer))
+    {
         attribs[i++] = WGL_FLOAT_COMPONENTS_NV;
 …
+{
     bool ret = false;
+    QGLWidget *dmy = 0;
+    if (!QGLContext::currentContext()) {
+        dmy = new QGLWidget;
+        dmy->makeCurrent();
+    }
+    QGLTemporaryContext *tmpContext = 0;
+    if (!QGLContext::currentContext())
+        tmpContext = new QGLTemporaryContext;
     PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
         (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
 …
+        }
+    }
     if (dmy)
         delete dmy;
+    if (tmpContext)
+        delete tmpContext;
     return ret;
+}

trunk/src/opengl/qglpixelbuffer_x11.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixmapfilter.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QGLBlurTextureInfo *takeBlurTextureInfo(const QPixmap &pixmap);
     bool hasBlurTextureInfo(const QPixmap &pixmap) const;
+    bool hasBlurTextureInfo(quint64 cacheKey) const;
     void insertBlurTextureInfo(const QPixmap &pixmap, QGLBlurTextureInfo *info);
     void clearBlurTextureInfo(const QPixmap &pixmap);
+    void clearBlurTextureInfo(quint64 cacheKey);
     void timerEvent(QTimerEvent *event);
 private:
     static void pixmapDestroyed(QPixmap *pixmap);
+    static void pixmapDestroyed(QPixmapData *pixmap);
     QCache<quint64, QGLBlurTextureInfo > cache;
 …
+}
 void QGLBlurTextureCache::clearBlurTextureInfo(const QPixmap &pixmap)
+{
     cache.remove(pixmap.cacheKey());
+}
 bool QGLBlurTextureCache::hasBlurTextureInfo(const QPixmap &pixmap) const
+{
     return cache.contains(pixmap.cacheKey());
+void QGLBlurTextureCache::clearBlurTextureInfo(quint64 cacheKey)
+{
+    cache.remove(cacheKey);
+}
+bool QGLBlurTextureCache::hasBlurTextureInfo(quint64 cacheKey) const
+{
+    return cache.contains(cacheKey);
+}
 …
     static bool hookAdded = false;
     if (!hookAdded) {
         QImagePixmapCleanupHooks::instance()->addPixmapDestructionHook(pixmapDestroyed);
+        QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(pixmapDestroyed);
         hookAdded = true;
+    }
 …
+}
 void QGLBlurTextureCache::pixmapDestroyed(QPixmap *pixmap)
+void QGLBlurTextureCache::pixmapDestroyed(QPixmapData *pmd)
+{
     foreach (QGLBlurTextureCache *cache, blurTextureCaches) {
         if (cache->hasBlurTextureInfo(*pixmap))
             cache->clearBlurTextureInfo(*pixmap);
+        if (cache->hasBlurTextureInfo(pmd->cacheKey()))
+            cache->clearBlurTextureInfo(pmd->cacheKey());
+    }
+}

trunk/src/opengl/qglpixmapfilter_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglscreen_qws.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglscreen_qws.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglshaderprogram.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     \snippet doc/src/snippets/code/src_opengl_qglshaderprogram.cpp 2
+    \section1 Binary shaders and programs
+    Binary shaders may be specified using \c{glShaderBinary()} on
+    the return value from QGLShader::shaderId().  The QGLShader instance
+    containing the binary can then be added to the shader program with
+    addShader() and linked in the usual fashion with link().
+    Binary programs may be specified using \c{glProgramBinaryOES()}
+    on the return value from programId().  Then the application should
+    call link(), which will notice that the program has already been
+    specified and linked, allowing other operations to be performed
+    on the shader program.
     \sa QGLShader
 …
             return false;
+        }
-        if (!shader->d_func()->compiled)
-            return false;
         if (!shader->d_func()->shaderGuard.id())
             return false;
 …
     if (!program)
         return false;
+    GLint value;
+    if (d->shaders.isEmpty()) {
+        // If there are no explicit shaders, then it is possible that the
+        // application added a program binary with glProgramBinaryOES(),
+        // or otherwise populated the shaders itself.  Check to see if the
+        // program is already linked and bail out if so.
+        value = 0;
+        glGetProgramiv(program, GL_LINK_STATUS, &value);
+        d->linked = (value != 0);
+        if (d->linked)
+            return true;
+    }
     glLinkProgram(program);
     GLint value = 0;
+    value = 0;
     glGetProgramiv(program, GL_LINK_STATUS, &value);
     d->linked = (value != 0);
 …
+{
     Q_D(const QGLShaderProgram);
+    GLuint id = d->programGuard.id();
+    if (id)
+        return id;
+    // Create the identifier if we don't have one yet.  This is for
+    // applications that want to create the attached shader configuration
+    // themselves, particularly those using program binaries.
+    if (!const_cast<QGLShaderProgram *>(this)->init())
+        return 0;
     return d->programGuard.id();
+}

trunk/src/opengl/qglshaderprogram.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglwindowsurface_qws.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglwindowsurface_qws_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicsshadereffect.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicsshadereffect_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicssystem_gl.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicssystem_gl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qpaintengine_opengl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+#ifdef Q_WS_X11
+static bool qt_nvidiaFboNeedsFinish = false;
+#endif
 static inline void qt_glColor4ubv(unsigned char *col)
+{
 …
 #ifdef Q_WS_X11
     // workaround for bug in nvidia driver versions 9x.xx
     if (QGLExtensions::nvidiaFboNeedsFinish)
+    if (qt_nvidiaFboNeedsFinish)
         glFinish();
 #endif
 …
 bool QGLOffscreen::isSupported()
+{
     return (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject); // for fbo
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject); // for fbo
+}
 …
             d->mv_matrix[i][j] = (i == j ? qreal(1) : qreal(0));
     bool has_frag_program = (QGLExtensions::glExtensions & QGLExtensions::FragmentProgram)
+    bool has_frag_program = (QGLExtensions::glExtensions() & QGLExtensions::FragmentProgram)
                             && (pdev->devType() != QInternal::Pixmap);
 …
     d->use_stencil_method = d->device->format().stencil()
                             && (QGLExtensions::glExtensions & QGLExtensions::StencilWrap);
+                            && (QGLExtensions::glExtensions() & QGLExtensions::StencilWrap);
     if (d->device->format().directRendering()
         && (d->use_stencil_method && QGLExtensions::glExtensions & QGLExtensions::StencilTwoSide))
+        && (d->use_stencil_method && QGLExtensions::glExtensions() & QGLExtensions::StencilTwoSide))
         d->has_stencil_face_ext = qt_resolve_stencil_face_extension(ctx);
+#ifdef Q_WS_X11
+    static bool nvidia_workaround_needs_init = true;
+    if (nvidia_workaround_needs_init) {
+        // nvidia 9x.xx unix drivers contain a bug which requires us to
+        // call glFinish before releasing an fbo to avoid painting
+        // artifacts
+        const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+        const int pos = versionString.indexOf("NVIDIA");
+        if (pos >= 0) {
+            const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
+            qt_nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
+        }
+        nvidia_workaround_needs_init = false;
+    }
+#endif
 #ifndef QT_OPENGL_ES
 …
         glDisableClientState(GL_VERTEX_ARRAY);
         if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+        if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
         glDisable(GL_TEXTURE_2D);
         if (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+        if (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
             glDisable(GL_TEXTURE_RECTANGLE_NV);
         glDisable(GL_STENCIL_TEST);
 …
     Q_UNUSED(brush);
 #else
     bool has_mirrored_repeat = QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat;
+    bool has_mirrored_repeat = QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat;
     Qt::BrushStyle style = brush.style();
 …
     return !(style == Qt::SolidPattern
              || (style == Qt::LinearGradientPattern
                  && (QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat)));
+                 && (QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat)));
+}
 …
         } else {
             d->high_quality_antialiasing = false;
             if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+            if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
+        }
     } else {
         d->high_quality_antialiasing = false;
         if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+        if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
+    }
 …
             DEBUG_ONCE_STR("Unable to initialize offscreen, disabling high quality antialiasing");
             d->high_quality_antialiasing = false;
             if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+            if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
+        }
 …
     d->has_antialiasing = d->high_quality_antialiasing
                           || ((hints & QPainter::Antialiasing)
                               && (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers));
+                              && (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers));
+}
 …
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    bool antialias = !(ti.fontEngine->fontDef.styleStrategy & QFont::NoAntialias);
+    bool antialias = !(ti.fontEngine->fontDef.styleStrategy & QFont::NoAntialias)
+                   && (d->matrix.type() > QTransform::TxTranslate);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);

trunk/src/opengl/qpaintengine_opengl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qpixmapdata_gl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     if (!m_source.isNull()) {
         if (external_format == GL_RGB) {
             const QImage tx = m_source.convertToFormat(QImage::Format_RGB888);
+            const QImage tx = m_source.convertToFormat(QImage::Format_RGB888).mirrored(false, true);
             glBindTexture(target, m_texture.id);

trunk/src/opengl/qpixmapdata_gl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qpixmapdata_x11gl_egl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 ****************************************************************************/
+#include <QDebug>
 #include <private/qgl_p.h>
 #include <private/qegl_p.h>
 #include <private/qeglproperties_p.h>
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
 #include <private/qpaintengineex_opengl2_p.h>
+#endif
+#ifndef QT_OPENGL_ES_2
+#include <private/qpaintengine_opengl_p.h>
+#endif
 #include "qpixmapdata_x11gl_p.h"
 …
+}
+static QGL2PaintEngineEx* qt_gl2_engine_for_pixmaps = 0;
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_pixmap_2_engine)
+#endif
+#ifndef QT_OPENGL_ES_2
+Q_GLOBAL_STATIC(QOpenGLPaintEngine, qt_gl_pixmap_engine)
+#endif
 QPaintEngine* QX11GLPixmapData::paintEngine() const
 …
+    }
+    if (!qt_gl2_engine_for_pixmaps)
+        qt_gl2_engine_for_pixmaps = new QGL2PaintEngineEx();
+    QPaintEngine* engine;
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+    engine = qt_gl_pixmap_engine();
+#elif defined(QT_OPENGL_ES_2)
+    engine = qt_gl_pixmap_2_engine();
+#else
+    if (qt_gl_preferGL2Engine())
+        engine = qt_gl_pixmap_2_engine();
+    else
+        engine = qt_gl_pixmap_engine();
+#endif
     // Support multiple painters on multiple pixmaps simultaniously
     if (qt_gl2_engine_for_pixmaps->isActive()) {
+    if (engine->isActive()) {
         qWarning("Pixmap paint engine already active");
+        QPaintEngine* engine = new QGL2PaintEngineEx();
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+        engine = new QOpenGLPaintEngine;
+#elif defined(QT_OPENGL_ES_2)
+        engine = new QGL2PaintEngineEx;
+#else
+        if (qt_gl_preferGL2Engine())
+            engine = new QGL2PaintEngineEx;
+        else
+            engine = new QOpenGLPaintEngine;
+#endif
         engine->setAutoDestruct(true);
         return engine;
+    }
     return qt_gl2_engine_for_pixmaps;
+    return engine;
+}

trunk/src/opengl/qpixmapdata_x11gl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qwindowsurface_gl.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+{
     Q_ASSERT(window->isTopLevel());
-    QGLExtensions::init();
     d_ptr->pb = 0;
     d_ptr->fbo = 0;
 …
     glDisable(GL_SCISSOR_TEST);
     if (d_ptr->fbo && (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit)) {
+    if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
         const int h = d_ptr->fbo->height();
 …
     if (d_ptr->destructive_swap_buffers
         && (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject)
+        && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
         && (d_ptr->fbo || !d_ptr->tried_fbo)
         && qt_gl_preferGL2Engine())
 …
         format.setTextureTarget(target);
         if (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit)
+        if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
             format.setSamples(8);

trunk/src/opengl/qwindowsurface_gl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qwindowsurface_x11gl.cpp

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qwindowsurface_x11gl_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/util/fragmentprograms_p.h

r561	r651
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/util/generator.cpp

-              r561
+              r651
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     out << "/****************************************************************************\n"
            "**\n"
            "** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).\n"
+           "** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).\n"
            "** All rights reserved.\n"
            "** Contact: Nokia Corporation (qt-info@nokia.com)\n"

trunk/src/opengl/util/glsl_to_include.sh

r561	r651
2	2	#############################################################################
3	3	##
4		## Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
	4	## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5	5	## All rights reserved.
6	6	## Contact: Nokia Corporation (qt-info@nokia.com)

/branches/vendor/nokia/qt/4.6.2 (added)	merged: 650
/branches/vendor/nokia/qt/current	merged: 649
/branches/vendor/nokia/qt/4.6.1	removed

Context Navigation

Legend:

Download in other formats: