Initial import of kinetic-dui branch from the old kinetic

1 files changed, 707 insertions, 0 deletions

diff --git a/src/declarative/opengl/glbasicshaders.cpp b/src/declarative/opengl/glbasicshaders.cpp
new file mode 100644
index 0000000..e95e53f
--- /dev/null
+++ b/src/declarative/opengl/glbasicshaders.cpp
@@ -0,0 +1,707 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "glbasicshaders.h"
+#include <QDebug>
+#include <QColor>
+
+
+QT_BEGIN_NAMESPACE
+SingleTextureVertexOpacityShader::SingleTextureVertexOpacityShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute lowp float myOpacity;\
+            attribute mediump vec4 myUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            varying lowp float myFragOpacity;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+                myFragOpacity = myOpacity;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            varying mediump vec2 myTexCoord;\
+            varying lowp float myFragOpacity;\
+            void main(void)\
+            {\
+                mediump vec4 frag = texture2D(sampler2d,myTexCoord);\
+                gl_FragColor = vec4(frag.rgb, frag.a * myFragOpacity);\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+    bindAttributeLocation("myOpacity", OpacityCoords);
+}
+
+bool SingleTextureVertexOpacityShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    enable();
+    setUniformValue("sampler2d", 0);
+    disable();
+    return true;
+}
+
+void SingleTextureVertexOpacityShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+BlurTextureShader::BlurTextureShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+            }"
+            );
+
+#if 0
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform bool horizontal; \
+            uniform mediump float blurStep; \
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 accum = vec4(0, 0, 0, 0); \
+                mediump vec2 offset; \
+                if(horizontal) \
+                    offset = vec2(blurStep, 0); \
+                else \
+                    offset = vec2(0, blurStep); \
+                accum += texture2D(sampler2d, myTexCoord + 2.0 * offset); \
+                accum += 2.0 * texture2D(sampler2d, myTexCoord + 1.0 * offset); \
+                accum += 4.0 * texture2D(sampler2d, myTexCoord + 0.0 * offset); \
+                accum += 2.0 * texture2D(sampler2d, myTexCoord - 1.0 * offset); \
+                accum += texture2D(sampler2d, myTexCoord - 2.0 * offset); \
+                gl_FragColor = accum / 10.0; \
+            }"
+            );
+#else
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform bool horizontal; \
+            uniform mediump float blurStep; \
+            uniform int blurSteps; \
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 accum = vec4(0, 0, 0, 0); \
+                mediump vec2 offset; \
+                if(horizontal) \
+                    offset = vec2(blurStep, 0); \
+                else \
+                    offset = vec2(0, blurStep); \
+                mediump float sum = 0.0; \
+                for(int ii = 0; ii < blurSteps; ++ii) { \
+                    mediump float frac = float(blurSteps - ii) / float(blurSteps); \
+                    mediump vec2 coord = myTexCoord + -float(ii) * offset; \
+                    if(coord.x >= 0.0 && coord.y >= 0.0 && coord.y <= 1.0 && coord.x <=1.0) \
+                        accum += texture2D(sampler2d, coord) * frac; \
+                    sum += frac; \
+                } \
+                for(int ii = 1; ii < blurSteps; ++ii) { \
+                    mediump float frac = float(blurSteps - ii) / float(blurSteps); \
+                    mediump vec2 coord = myTexCoord + float(ii) * offset; \
+                    if(coord.x <= 1.0 && coord.y <= 1.0 && coord.x >= 0.0 && coord.y >= 0.0) \
+                        accum += texture2D(sampler2d, coord) * frac; \
+                    sum += frac; \
+                } \
+                gl_FragColor = accum / sum; \
+            }"
+            );
+#endif
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+}
+
+bool BlurTextureShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    mode = uniformLocation("horizontal");
+    step = uniformLocation("blurStep");
+    steps = uniformLocation("blurSteps");
+    enable();
+    setUniformValue("sampler2d", 0);
+    disable();
+    return true;
+}
+
+void BlurTextureShader::setStep(float f)
+{
+    setUniformValue(step, f);
+}
+
+void BlurTextureShader::setSteps(int s)
+{
+    setUniformValue(steps, s);
+}
+
+void BlurTextureShader::setMode(Mode m)
+{
+    if(m == Horizontal)
+        setUniformValue(mode, 1);
+    else
+        setUniformValue(mode, 0);
+}
+
+void BlurTextureShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+DualTextureBlendShader::DualTextureBlendShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            attribute mediump vec4 myBlendUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            varying mediump vec2 myBlendTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+                myBlendTexCoord = myBlendUV.st;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform sampler2D sampler2dBlend;\
+            uniform lowp float myOpacity;\
+            uniform lowp float myBlend; \
+            varying mediump vec2 myTexCoord;\
+            varying mediump vec2 myBlendTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 tex = texture2D(sampler2d,myTexCoord);\
+                mediump vec4 blendtex = texture2D(sampler2dBlend, myBlendTexCoord);\
+                gl_FragColor = mix(tex, blendtex, myBlend) * myOpacity; \
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+    bindAttributeLocation("myBlendUV", BlendTextureCoords);
+}
+
+bool DualTextureBlendShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    opacity = uniformLocation("myOpacity");
+    blend = uniformLocation("myBlend");
+    enable();
+    setUniformValue("sampler2d", 0);
+    setUniformValue("sampler2dBlend", 1);
+    disable();
+    return true;
+}
+
+void DualTextureBlendShader::setOpacity(GLfloat o)
+{
+    setUniformValue(opacity, o);
+}
+
+void DualTextureBlendShader::setBlend(GLfloat b)
+{
+    setUniformValue(blend, b);
+}
+
+void DualTextureBlendShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+DualTextureAddShader::DualTextureAddShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            attribute mediump vec4 myAddUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            varying mediump vec2 myAddTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+                myAddTexCoord = myAddUV.st;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform sampler2D sampler2dAdd;\
+            uniform lowp float myOpacity;\
+            varying mediump vec2 myTexCoord;\
+            varying mediump vec2 myAddTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 tex = texture2D(sampler2d,myTexCoord);\
+                mediump vec4 addtex = texture2D(sampler2dAdd, myAddTexCoord);\
+                tex = tex + vec4(addtex.rgb * addtex.a * tex.a, 0); \
+                tex = min(tex, vec4(1, 1, 1, 1)); \
+                gl_FragColor = vec4(tex.rgb, tex.a) * myOpacity;\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+    bindAttributeLocation("myAddUV", AddTextureCoords);
+}
+
+void DualTextureAddShader::setOpacity(GLfloat f)
+{
+    setUniformValue(opacity, f);
+}
+
+void DualTextureAddShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+bool DualTextureAddShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    opacity = uniformLocation("myOpacity");
+    enable();
+    setUniformValue("sampler2d", 0);
+    setUniformValue("sampler2dAdd", 1);
+    disable();
+    return true;
+}
+
+SingleTextureShader::SingleTextureShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                gl_FragColor = texture2D(sampler2d,myTexCoord);\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+}
+
+bool SingleTextureShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    enable();
+    setUniformValue("sampler2d", 0);
+    disable();
+    return true;
+}
+
+void SingleTextureShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+ConstantColorShader::ConstantColorShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            uniform mediump mat4 myPMVMatrix;\
+            attribute highp vec4 myVertex;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex; \
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform lowp vec4 myColor;\
+            void main(void)\
+            {\
+                gl_FragColor = myColor;\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+}
+
+void ConstantColorShader::setColor(const QColor &c)
+{
+    setUniformValue(color, c);
+}
+
+void ConstantColorShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+bool ConstantColorShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    color = uniformLocation("myColor");
+    return true;
+}
+
+ColorShader::ColorShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            uniform mediump mat4 myPMVMatrix;\
+            attribute highp vec4 myVertex;\
+            attribute lowp vec4 myColors;\
+            varying lowp vec4 myColor;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex; \
+                myColor = myColors; \
+            }"
+            );
+
+    frag.setSourceCode("\
+            varying lowp vec4 myColor;\
+            void main(void)\
+            {\
+                gl_FragColor = myColor;\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myColors", Colors);
+}
+
+void ColorShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+bool ColorShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    return true;
+}
+
+class GLBasicShadersPrivate
+{
+public:
+    GLBasicShadersPrivate();
+    ~GLBasicShadersPrivate();
+
+    BlurTextureShader *blurTexture;
+    SingleTextureShader *singleTexture;
+    SingleTextureOpacityShader *singleTextureOpacity;
+    DualTextureAddShader *dualTextureAdd;
+    SingleTextureShadowShader *singleTextureShadow;
+    SingleTextureVertexOpacityShader *singleTextureVertexOpacity;
+    ConstantColorShader *constantColor;
+    ColorShader *color;
+};
+
+GLBasicShadersPrivate::GLBasicShadersPrivate()
+: blurTexture(0), singleTexture(0), singleTextureOpacity(0), 
+  dualTextureAdd(0), singleTextureShadow(0), singleTextureVertexOpacity(0), 
+  constantColor(0), color(0)
+{
+}
+
+GLBasicShadersPrivate::~GLBasicShadersPrivate()
+{
+    delete blurTexture;
+    delete singleTexture;
+    delete singleTextureOpacity; 
+    delete dualTextureAdd;
+    delete singleTextureVertexOpacity; 
+    delete singleTextureShadow;
+    delete constantColor;
+    delete color;
+}
+
+GLBasicShaders::GLBasicShaders()
+: d(new GLBasicShadersPrivate)
+{
+}
+
+GLBasicShaders::~GLBasicShaders()
+{
+    delete d;
+}
+
+BlurTextureShader *GLBasicShaders::blurTexture()
+{
+    if(!d->blurTexture) d->blurTexture = new BlurTextureShader();
+    return d->blurTexture;
+}
+
+SingleTextureShader *GLBasicShaders::singleTexture()
+{
+    if(!d->singleTexture) d->singleTexture = new SingleTextureShader();
+    return d->singleTexture;
+}
+
+SingleTextureOpacityShader *GLBasicShaders::singleTextureOpacity()
+{
+    if(!d->singleTextureOpacity) d->singleTextureOpacity = new SingleTextureOpacityShader();
+    return d->singleTextureOpacity;
+}
+
+DualTextureAddShader *GLBasicShaders::dualTextureAdd()
+{
+    if(!d->dualTextureAdd) d->dualTextureAdd = new DualTextureAddShader();
+    return d->dualTextureAdd;
+}
+
+SingleTextureVertexOpacityShader *GLBasicShaders::singleTextureVertexOpacity()
+{
+    if(!d->singleTextureVertexOpacity) d->singleTextureVertexOpacity = new SingleTextureVertexOpacityShader();
+    return d->singleTextureVertexOpacity;
+}
+
+SingleTextureShadowShader *GLBasicShaders::singleTextureShadow()
+{
+    if(!d->singleTextureShadow) d->singleTextureShadow = new SingleTextureShadowShader();
+    return d->singleTextureShadow;
+}
+
+ConstantColorShader *GLBasicShaders::constantColor()
+{
+    if(!d->constantColor) d->constantColor = new ConstantColorShader();
+    return d->constantColor;
+}
+
+ColorShader *GLBasicShaders::color()
+{
+    if(!d->color) d->color = new ColorShader();
+    return d->color;
+}
+
+SingleTextureOpacityShader::SingleTextureOpacityShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform lowp float myOpacity;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 tex = texture2D(sampler2d,myTexCoord);\
+                gl_FragColor = vec4(tex.rgb, myOpacity * tex.a);\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+}
+
+bool SingleTextureOpacityShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    opacity = uniformLocation("myOpacity");
+    enable();
+    setUniformValue("sampler2d", 0);
+    disable();
+    return true;
+}
+
+void SingleTextureOpacityShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+void SingleTextureOpacityShader::setOpacity(GLfloat f)
+{
+    setUniformValue(opacity, f);
+}
+
+SingleTextureShadowShader::SingleTextureShadowShader()
+{
+    QGLShader vert(QGLShader::VertexShader);
+    QGLShader frag(QGLShader::FragmentShader);
+
+    vert.setSourceCode("\
+            attribute highp vec4 myVertex;\
+            attribute mediump vec4 myUV;\
+            uniform mediump mat4 myPMVMatrix;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                gl_Position = myPMVMatrix * myVertex;\
+                myTexCoord = myUV.st;\
+            }"
+            );
+
+    frag.setSourceCode("\
+            uniform sampler2D sampler2d;\
+            uniform lowp float myOpacity;\
+            varying mediump vec2 myTexCoord;\
+            void main(void)\
+            {\
+                mediump vec4 tex = texture2D(sampler2d,myTexCoord);\
+                gl_FragColor = vec4(0, 0, 0, myOpacity * tex.a * .75);\
+            }"
+            );
+
+    addShader(&vert);
+    addShader(&frag);
+
+    bindAttributeLocation("myVertex", Vertices);
+    bindAttributeLocation("myUV", TextureCoords);
+}
+
+bool SingleTextureShadowShader::link()
+{
+    if (!QGLShaderProgram::link())
+        return false;
+    transform = uniformLocation("myPMVMatrix");
+    opacity = uniformLocation("myOpacity");
+    enable();
+    setUniformValue("sampler2d", 0);
+    disable();
+    return true;
+}
+
+void SingleTextureShadowShader::setTransform(const QMatrix4x4 &matrix)
+{
+    setUniformValue(transform, matrix);
+}
+
+void SingleTextureShadowShader::setOpacity(GLfloat f)
+{
+    setUniformValue(opacity, f);
+}
+QT_END_NAMESPACE