Clean up existing & implement missing GLSL for new shader manager

4 files changed, 320 insertions, 154 deletions

diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
index 1086430..ea01604 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
@@ -40,12 +40,20 @@
 ****************************************************************************/
 
 #include "qglengineshadermanager_p.h"
+#include "qglengineshadersource_p.h"
 
 #if defined(QT_DEBUG)
 #include <QMetaEnum>
 #endif
 
 
+const char* QGLEngineShaderManager::qglEngineShaderSourceCode[] = {
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0
+};
+
 QGLEngineShaderManager::QGLEngineShaderManager(QGLContext* context)
     : ctx(context),
       shaderProgNeedsChanging(true),
@@ -58,6 +66,77 @@ QGLEngineShaderManager::QGLEngineShaderManager(QGLContext* context)
       currentShaderProg(0)
 {
     memset(compiledShaders, 0, sizeof(compiledShaders));
+
+/*
+    Rather than having the shader source array statically initialised, it is initialised
+    here instead. This is to allow new shader names to be inserted or existing names moved
+    around without having to change the order of the glsl strings. It is hoped this will
+    make future hard-to-find runtime bugs more obvious and generally give more solid code.
+*/
+    static bool qglEngineShaderSourceCodePopulated = false;
+    if (!qglEngineShaderSourceCodePopulated) {
+
+        const char** code = qglEngineShaderSourceCode; // shortcut
+
+        code[SimpleVertexShader] = qglslSimpleVertexShader;
+        code[MainVertexShader] = qglslMainVertexShader;
+        code[MainWithTexCoordsVertexShader] = qglslMainWithTexCoordsVertexShader;
+
+        code[PositionOnlyVertexShader] = qglslPositionOnlyVertexShader;
+        code[PositionWithPatternBrushVertexShader] = qglslPositionWithPatternBrushVertexShader;
+        code[PositionWithLinearGradientBrushVertexShader] = qglslPositionWithLinearGradientBrushVertexShader;
+        code[PositionWithConicalGradientBrushVertexShader] = qglslPositionWithConicalGradientBrushVertexShader;
+        code[PositionWithRadialGradientBrushVertexShader] = qglslPositionWithRadialGradientBrushVertexShader;
+        code[PositionWithTextureBrushVertexShader] = qglslPositionWithTextureBrushVertexShader;
+        code[AffinePositionWithPatternBrushVertexShader] = qglslAffinePositionWithPatternBrushVertexShader;
+        code[AffinePositionWithLinearGradientBrushVertexShader] = qglslAffinePositionWithLinearGradientBrushVertexShader;
+        code[AffinePositionWithConicalGradientBrushVertexShader] = qglslAffinePositionWithConicalGradientBrushVertexShader;
+        code[AffinePositionWithRadialGradientBrushVertexShader] = qglslAffinePositionWithRadialGradientBrushVertexShader;
+        code[AffinePositionWithTextureBrushVertexShader] = qglslAffinePositionWithTextureBrushVertexShader;
+
+        code[MainFragmentShader_CMO] = qglslMainFragmentShader_CMO;
+        code[MainFragmentShader_CM] = qglslMainFragmentShader_CM;
+        code[MainFragmentShader_MO] = qglslMainFragmentShader_MO;
+        code[MainFragmentShader_M] = qglslMainFragmentShader_M;
+        code[MainFragmentShader_CO] = qglslMainFragmentShader_CO;
+        code[MainFragmentShader_C] = qglslMainFragmentShader_C;
+        code[MainFragmentShader_O] = qglslMainFragmentShader_O;
+        code[MainFragmentShader] = qglslMainFragmentShader;
+
+        code[ImageSrcFragmentShader] = qglslImageSrcFragmentShader;
+        code[NonPremultipliedImageSrcFragmentShader] = qglslNonPremultipliedImageSrcFragmentShader;
+        code[SolidBrushSrcFragmentShader] = qglslSolidBrushSrcFragmentShader;
+        code[TextureBrushSrcFragmentShader] = qglslTextureBrushSrcFragmentShader;
+        code[PatternBrushSrcFragmentShader] = qglslPatternBrushSrcFragmentShader;
+        code[LinearGradientBrushSrcFragmentShader] = qglslLinearGradientBrushSrcFragmentShader;
+        code[RadialGradientBrushSrcFragmentShader] = qglslRadialGradientBrushSrcFragmentShader;
+        code[ConicalGradientBrushSrcFragmentShader] = qglslConicalGradientBrushSrcFragmentShader;
+
+        code[MaskFragmentShader] = qglslMaskFragmentShader;
+        code[RgbMaskFragmentShader] = ""; //###
+        code[RgbMaskWithGammaFragmentShader] = ""; //###
+
+        code[MultiplyCompositionModeFragmentShader] = ""; //###
+        code[ScreenCompositionModeFragmentShader] = ""; //###
+        code[OverlayCompositionModeFragmentShader] = ""; //###
+        code[DarkenCompositionModeFragmentShader] = ""; //###
+        code[LightenCompositionModeFragmentShader] = ""; //###
+        code[ColorDodgeCompositionModeFragmentShader] = ""; //###
+        code[ColorBurnCompositionModeFragmentShader] = ""; //###
+        code[HardLightCompositionModeFragmentShader] = ""; //###
+        code[SoftLightCompositionModeFragmentShader] = ""; //###
+        code[DifferenceCompositionModeFragmentShader] = ""; //###
+        code[ExclusionCompositionModeFragmentShader] = ""; //###
+
+#if defined(QT_DEBUG)
+        // Check that all the elements have been filled:
+        for (int i = 0; i < TotalShaderCount; ++i) {
+            if (qglEngineShaderSourceCode[i] == 0)
+                qCritical() << "qglEngineShaderSourceCode: Missing shader in element" << i;
+        }
+#endif
+        qglEngineShaderSourceCodePopulated = true;
+    }
 }
 
 QGLEngineShaderManager::~QGLEngineShaderManager()
@@ -303,15 +382,6 @@ void QGLEngineShaderManager::useCorrectShaderProg()
         }
     }
 
-/*
-    QGLShader*          mainVertexShader;
-    QGLShader*          positionVertexShader;
-    QGLShader*          mainFragShader;
-    QGLShader*          srcPixelFragShader;
-    QGLShader*          maskFragShader;        // Can be null for no mask
-    QGLShader*          compositionFragShader; // Can be null for GL-handled mode
-    QGLShaderProgram*   program;
-*/
     // Shader program not found in cache, create it now.
     requiredProgram.program = new QGLShaderProgram(ctx, this);
     requiredProgram.program->addShader(requiredProgram.mainVertexShader);
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
index fe30a70..38c1cff 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
@@ -375,8 +375,9 @@ private:
     QGLShader* compiledShaders[TotalShaderCount];
 
     void compileNamedShader(QGLEngineShaderManager::ShaderName name, QGLShader::ShaderType type);
-};
 
+    static const char* qglEngineShaderSourceCode[TotalShaderCount];
+};
 
 QT_END_NAMESPACE
 
diff --git a/src/opengl/gl2paintengineex/glgc_shader_source.h b/src/opengl/gl2paintengineex/qglengineshadersource_p.h
index 5184c78..945c56c 100644
--- a/src/opengl/gl2paintengineex/glgc_shader_source.h
+++ b/src/opengl/gl2paintengineex/qglengineshadersource_p.h
@@ -39,8 +39,22 @@
 **
 ****************************************************************************/
 
-#ifndef GLGC_SHADER_SOURCE_H
-#define GLGC_SHADER_SOURCE_H
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+
+#ifndef QGL_ENGINE_SHADER_SOURCE_H
+#define QGL_ENGINE_SHADER_SOURCE_H
+
+#include "qglengineshadermanager_p.h"
 
 QT_BEGIN_HEADER
 
@@ -49,126 +63,50 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(OpenGL)
 
 
-static const char* qglslImageVertexShader = "\
-    attribute highp vec4    inputVertex; \
-    attribute lowp  vec2    textureCoord; \
-    uniform   highp mat4    pmvMatrix; \
-    varying   lowp  vec2    fragTextureCoord; \
-    void main(void) \
+static const char* const qglslSimpleVertexShader = "\
+    attribute highp vec4    inputVertex;\
+    uniform   highp mat4    pmvMatrix;\
+    void main(void)\
     {\
             gl_Position = pmvMatrix * inputVertex;\
-            fragTextureCoord = textureCoord; \
     }";
 
-static const char* qglslImageFragmentShader = "\
-    varying lowp vec2      fragTextureCoord;\
-    uniform      sampler2D textureSampler;\
-    uniform lowp float     opacity; \
-    void main(void) \
+static const char* const qglslMainVertexShader = "\
+    void setPosition();\
+    void main(void)\
     {\
-        gl_FragColor = texture2D(textureSampler, fragTextureCoord) * opacity; \
+            setPosition();\
     }";
 
-static const char* qglslTextFragmentShader = "\
-    varying lowp    vec2      fragTextureCoord;\
-    uniform mediump vec4      fragmentColor;\
-    uniform         sampler2D textureSampler;\
+static const char* const qglslMainWithTexCoordsVertexShader = "\
+    attribute lowp  vec2    textureCoord; \
+    varying   lowp  vec2    fragTextureCoord; \
+    void setPosition();\
     void main(void) \
     {\
-        highp vec4 tex = texture2D(textureSampler, fragTextureCoord); \
-        tex = fragmentColor * tex.r; \
-        gl_FragColor = tex; \
+            setPosition();\
+            fragTextureCoord = textureCoord; \
     }";
 
-static const char* qglslDefaultVertexShader = "\
+
+static const char* const qglslPositionOnlyVertexShader = "\
     attribute highp vec4    inputVertex;\
     uniform   highp mat4    pmvMatrix;\
-    void main(void)\
+    void setPosition(void)\
     {\
             gl_Position = pmvMatrix * inputVertex;\
     }";
 
-static const char* qglslSimpleFragmentShader = "\
-    void main (void)\
-    {\
-            gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\
-    }";
-
-
-/**** FRAGMENT SHADER MAIN FUNCTIONS ****/
-// NOTE: Currently, the engine assumes brushes return colors already in pre-multiplied
-//       format. However, this may change if we add support for non-premultiplied 
-
-static const char* qglslNoOpacityFragmentShaderMain = "\n\
-    mediump vec4 brush();\
-    void main (void)\
-    {\
-            gl_FragColor = brush();\
-    }\n";
-
-static const char* qglslFragmentShaderMain = "\n\
-    mediump vec4    brush();\
-    uniform lowp    float   opacity; \
-    void main (void)\
-    {\
-        gl_FragColor = brush() * opacity;\
-    }\n";
-
-
-
-/**** BRUSH SHADERS ****/
-
-// This should never actually be used
-static const char* qglslNoBrushFragmentShader = "\n\
-    mediump vec4 brush() { \
-        discard; \
-        return vec4(1.0, 0.8, 0.8, 1.0);\
-    }\n";
-
-// Solid Fill Brush
-static const char* qglslSolidBrushFragmentShader = "\n\
-    uniform mediump vec4 fragmentColor; \
-    mediump vec4 brush() { \
-        return fragmentColor;\
-    }\n";
-
-// Texture Brush
-static const char* qglslTextureBrushVertexShader = "\
-    attribute highp   vec4  inputVertex; \
-    uniform   highp   mat4  pmvMatrix; \
-    uniform   mediump vec2  halfViewportSize; \
-    uniform   mediump vec2  invertedTextureSize; \
-    uniform   mediump mat3  brushTransform; \
-    varying   mediump vec2  texCoords; \
-    void main(void) { \
-            gl_Position = pmvMatrix * inputVertex;\
-            gl_Position.xy = gl_Position.xy / gl_Position.w; \
-            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.xy = gl_Position.xy * invertedHTexCoordsZ; \
-            gl_Position.w = invertedHTexCoordsZ; \
-            texCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \
-            texCoords.y = -texCoords.y; \
-    }";
-
-static const char* qglslTextureBrushFragmentShader = "\n\
-    varying mediump vec2      texCoords;\
-    uniform         sampler2D brushTexture;\
-    mediump vec4 brush() { \
-        return texture2D(brushTexture, texCoords); \
-    }\n";
-
 
 // Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125
-static const char* qglslPatternBrushVertexShader = "\
+static const char* const qglslPositionWithPatternBrushVertexShader = "\
     attribute highp   vec4  inputVertex; \
     uniform   highp   mat4  pmvMatrix; \
     uniform   mediump vec2  halfViewportSize; \
     uniform   mediump vec2  invertedTextureSize; \
     uniform   mediump mat3  brushTransform; \
-    varying   mediump vec2  texCoords; \
-    void main(void) { \
+    varying   mediump vec2  patternTexCoords; \
+    void setPosition(void) { \
             gl_Position = pmvMatrix * inputVertex;\
             gl_Position.xy = gl_Position.xy / gl_Position.w; \
             mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
@@ -176,28 +114,31 @@ static const char* qglslPatternBrushVertexShader = "\
             mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \
             gl_Position.xy = gl_Position.xy * invertedHTexCoordsZ; \
             gl_Position.w = invertedHTexCoordsZ; \
-            texCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \
-            texCoords.y = -texCoords.y; \
+            patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \
+            patternTexCoords.y = -patternTexCoords.y; \
     }";
 
-static const char* qglslPatternBrushFragmentShader = "\n\
+static const char* const qglslAffinePositionWithPatternBrushVertexShader
+                 = qglslPositionWithPatternBrushVertexShader;
+
+static const char* const qglslPatternBrushSrcFragmentShader = "\
     uniform         sampler2D brushTexture;\
     uniform lowp    vec4      patternColor; \
-    varying mediump vec2      texCoords;\
-    mediump vec4 brush() { \
-        return patternColor * texture2D(brushTexture, texCoords).r; \
+    varying mediump vec2      patternTexCoords;\
+    lowp vec4 srcPixel() { \
+        return patternColor * texture2D(brushTexture, patternTexCoords).r; \
     }\n";
 
 
 // Linear Gradient Brush
-static const char* qglslLinearGradientBrushVertexShader = "\
+static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\
     attribute highp   vec4  inputVertex; \
     uniform   highp   mat4  pmvMatrix; \
     uniform   mediump vec2  halfViewportSize; \
     uniform   highp   vec3  linearData; \
-    uniform   mediump mat3  brushTransform; \
+    uniform   highp   mat3  brushTransform; \
     varying   mediump float index ; \
-    void main() { \
+    void setPosition() { \
         gl_Position = pmvMatrix * inputVertex;\
         gl_Position.xy = gl_Position.xy / gl_Position.w; \
         mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \
@@ -208,16 +149,55 @@ static const char* qglslLinearGradientBrushVertexShader = "\
         index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \
     }";
 
-static const char* qglslLinearGradientBrushFragmentShader = "\n\
+static const char* const qglslAffinePositionWithLinearGradientBrushVertexShader
+                 = qglslPositionWithLinearGradientBrushVertexShader;
+
+static const char* const qglslLinearGradientBrushSrcFragmentShader = "\
     uniform         sampler2D   brushTexture; \
     varying mediump float       index; \
-    mediump vec4 brush() { \
+    lowp vec4 srcPixel() { \
         mediump vec2 val = vec2(index, 0.5); \
         return texture2D(brushTexture, val); \
     }\n";
 
 
-static const char* qglslRadialGradientBrushVertexShader = "\
+// Conical Gradient Brush
+static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\
+    attribute highp   vec4  inputVertex;\
+    uniform   highp   mat4  pmvMatrix;\
+    uniform   mediump vec2  halfViewportSize; \
+    uniform   highp   mat3  brushTransform; \
+    varying   highp   vec2  A; \
+    void setPosition(void)\
+    {\
+        gl_Position = pmvMatrix * inputVertex;\
+        gl_Position.xy = gl_Position.xy / gl_Position.w; \
+        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.xy = gl_Position.xy * invertedHTexCoordsZ; \
+        gl_Position.w = invertedHTexCoordsZ; \
+        A = hTexCoords.xy * invertedHTexCoordsZ; \
+    }";
+
+static const char* const qglslAffinePositionWithConicalGradientBrushVertexShader
+                 = qglslPositionWithConicalGradientBrushVertexShader;
+
+static const char* const qglslConicalGradientBrushSrcFragmentShader = "\
+    #define INVERSE_2PI 0.1591549430918953358 \n\
+    uniform         sampler2D   brushTexture; \
+    uniform mediump float       angle; \
+    varying highp   vec2        A; \
+    lowp vec4 srcPixel() { \
+        if (abs(A.y) == abs(A.x)) \
+            A.y += 0.002; \
+        highp float t = (atan2(-A.y, A.x) + angle) * INVERSE_2PI; \
+        return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \
+    }";
+
+
+// Radial Gradient Brush
+static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\
     attribute highp   vec4 inputVertex;\
     uniform   highp   mat4 pmvMatrix;\
     uniform   mediump vec2 halfViewportSize; \
@@ -225,7 +205,7 @@ static const char* qglslRadialGradientBrushVertexShader = "\
     uniform   highp   vec2 fmp; \
     varying   highp   float b; \
     varying   highp   vec2  A; \
-    void main(void) \
+    void setPosition(void) \
     {\
         gl_Position = pmvMatrix * inputVertex;\
         gl_Position.xy = gl_Position.xy / gl_Position.w; \
@@ -236,51 +216,166 @@ static const char* qglslRadialGradientBrushVertexShader = "\
         gl_Position.w = invertedHTexCoordsZ; \
         A = hTexCoords.xy * invertedHTexCoordsZ; \
         b = 2.0 * fmp * (A.x + A.y); \
-\
     }";
 
-static const char* qglslRadialGradientBrushFragmentShader = "\n\
+static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader
+                 = qglslPositionWithRadialGradientBrushVertexShader;
+
+static const char* const qglslRadialGradientBrushSrcFragmentShader = "\
     uniform         sampler2D   brushTexture; \
     uniform highp   float       fmp2_m_radius2; \
     uniform highp   float       inverse_2_fmp2_m_radius2; \
-    varying   highp   float b; \
-    varying   highp   vec2  A; \
-\
-    mediump vec4 brush() { \
+    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); \
-    }\n";
+    }";
 
-static const char* qglslConicalGradientBrushVertexShader = "\
-    attribute highp vec4    inputVertex;\
-    uniform   highp mat4    pmvMatrix;\
+
+// Texture Brush
+static const char* const qglslPositionWithTextureBrushVertexShader = "\
+    attribute highp   vec4  inputVertex; \
+    uniform   highp   mat4  pmvMatrix; \
     uniform   mediump vec2  halfViewportSize; \
-    uniform highp   mat3    brushTransform; \
-    varying highp   vec2    A; \
-    void main(void)\
+    uniform   mediump vec2  invertedTextureSize; \
+    uniform   mediump mat3  brushTransform; \
+    varying   mediump vec2  textureTexCoords; \
+    void setPosition(void) { \
+            gl_Position = pmvMatrix * inputVertex;\
+            gl_Position.xy = gl_Position.xy / gl_Position.w; \
+            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.xy = gl_Position.xy * invertedHTexCoordsZ; \
+            gl_Position.w = invertedHTexCoordsZ; \
+            textureTexCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \
+            textureTexCoords.y = -textureTexCoords.y; \
+    }";
+
+static const char* const qglslAffinePositionWithTextureBrushVertexShader
+                 = qglslPositionWithTextureBrushVertexShader;
+
+static const char* const qglslTextureBrushSrcFragmentShader = "\
+    varying mediump vec2      textureTexCoords; \
+    uniform         sampler2D brushTexture; \
+    lowp vec4 srcPixel() { \
+        return texture2D(brushTexture, textureTexCoords); \
+    }";
+
+
+// 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      texCoord; \
+    uniform       sampler2D textureSampler; \
+    lowp vec4 srcPixel() { \
+        return texture2D(textureSampler, texCoord); \
+    }";
+
+static const char* const qglslNonPremultipliedImageSrcFragmentShader = "\
+    varying highp vec2      texCoord; \
+    uniform       sampler2D textureSampler; \
+    lowp vec4 srcPixel() { \
+        lowp vec4 sample = texture2D(textureSampler, texCoord); \
+        sample.rgb = sample.rgb * sample.a; \
+        return sample; \
+    }";
+
+
+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 = compose(applyMask(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 = compose(applyMask(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      texCoord;\
+    uniform         sampler2D maskTextureSampler;\
+    lowp vec4 applyMask(lowp vec4 src) \
     {\
-        gl_Position = pmvMatrix * inputVertex;\
-        gl_Position.xy = gl_Position.xy / gl_Position.w; \
-        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.xy = gl_Position.xy * invertedHTexCoordsZ; \
-        gl_Position.w = invertedHTexCoordsZ; \
-        A = hTexCoords.xy * invertedHTexCoordsZ; \
+        lowp vec4 mask = texture2D(maskTextureSampler, texCoord); \
+        return src * mask.a; \
     }";
 
-static const char* qglslConicalGradientBrushFragmentShader = "\n\
-    #define INVERSE_2PI 0.1591549430918953358 \n\
-    uniform         sampler2D   brushTexture; \
-    uniform mediump float       angle; \
-    varying highp   vec2        A; \
-    mediump vec4 brush() { \
-        if (abs(A.y) == abs(A.x)) \
-            A.y += 0.002; \
-        highp float t = (atan2(-A.y, A.x) + angle) * INVERSE_2PI; \
-        return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \
-    }\n";
+/*
+    Left to implement:
+        RgbMaskFragmentShader,
+        RgbMaskWithGammaFragmentShader,
+
+        MultiplyCompositionModeFragmentShader,
+        ScreenCompositionModeFragmentShader,
+        OverlayCompositionModeFragmentShader,
+        DarkenCompositionModeFragmentShader,
+        LightenCompositionModeFragmentShader,
+        ColorDodgeCompositionModeFragmentShader,
+        ColorBurnCompositionModeFragmentShader,
+        HardLightCompositionModeFragmentShader,
+        SoftLightCompositionModeFragmentShader,
+        DifferenceCompositionModeFragmentShader,
+        ExclusionCompositionModeFragmentShader,
+*/
 
 
 QT_END_NAMESPACE
diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro
index 1527f2d..8cf0e37 100644
--- a/src/opengl/opengl.pro
+++ b/src/opengl/opengl.pro
@@ -51,7 +51,7 @@ SOURCES	+= qgl.cpp \
                 gl2paintengineex/qglengineshadermanager_p.h \
                 gl2paintengineex/qgl2pexvertexarray_p.h \
                 gl2paintengineex/qpaintengineex_opengl2_p.h \
-                gl2paintengineex/glgc_shader_source.h
+                gl2paintengineex/qglengineshadersource_p.h
 #}