Merge branch 'stable' into dev

Conflicts:
	.qmake.conf

Change-Id: I10d4f9e993d23750a6e8ddc1291b79e47fc83c64

11 files changed, 578 insertions, 112 deletions

diff --git a/src/quick/scenegraph/util/qsgatlastexture.cpp b/src/quick/scenegraph/util/qsgatlastexture.cpp
index 3710f05b9a..8678d106ff 100644
--- a/src/quick/scenegraph/util/qsgatlastexture.cpp
+++ b/src/quick/scenegraph/util/qsgatlastexture.cpp
@@ -47,11 +47,14 @@
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QGuiApplication>
 #include <QtGui/QScreen>
+#include <QtGui/QSurface>
 
 #include <private/qsgtexture_p.h>
 
 #include <private/qqmlprofilerservice_p.h>
 
+QT_BEGIN_NAMESPACE
+
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
@@ -89,26 +92,36 @@ static int qsg_envInt(const char *name, int defaultValue)
 Manager::Manager()
     : m_atlas(0)
 {
-    QSize screenSize = QGuiApplication::primaryScreen()->geometry().size();
+    QOpenGLContext *gl = QOpenGLContext::currentContext();
+    Q_ASSERT(gl);
+    QSurface *surface = gl->surface();
+    QSize surfaceSize = surface->size();
     int max;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
-    int w = qMin(max, qsg_envInt("QSG_ATLAS_WIDTH", qsg_powerOfTwo(screenSize.width())));
-    int h = qMin(max, qsg_envInt("QSG_ATLAS_HEIGHT", qsg_powerOfTwo(screenSize.height())));
+
+    int w = qMin(max, qsg_envInt("QSG_ATLAS_WIDTH", qMax(512, qsg_powerOfTwo(surfaceSize.width()))));
+    int h = qMin(max, qsg_envInt("QSG_ATLAS_HEIGHT", qMax(512, qsg_powerOfTwo(surfaceSize.height()))));
 
     m_atlas_size_limit = qsg_envInt("QSG_ATLAS_SIZE_LIMIT", qMax(w, h) / 2);
     m_atlas_size = QSize(w, h);
+
+    if (qEnvironmentVariableIsSet("QSG_INFO"))
+        qDebug() << "QSG: texture atlas dimensions:" << w << "x" << h;
 }
 
 
 Manager::~Manager()
 {
-    invalidate();
+    Q_ASSERT(m_atlas == 0);
 }
 
 void Manager::invalidate()
 {
-    delete m_atlas;
-    m_atlas = 0;
+    if (m_atlas) {
+        m_atlas->invalidate();
+        m_atlas->deleteLater();
+        m_atlas = 0;
+    }
 }
 
 QSGTexture *Manager::create(const QImage &image)
@@ -118,10 +131,7 @@ QSGTexture *Manager::create(const QImage &image)
         if (!m_atlas)
             m_atlas = new Atlas(m_atlas_size);
         t = m_atlas->create(image);
-        if (t)
-            return t;
     }
-
     return t;
 }
 
@@ -139,6 +149,11 @@ Atlas::Atlas(const QSize &size)
             || strstr(ext, "GL_EXT_texture_format_BGRA8888")
             || strstr(ext, "GL_IMG_texture_format_BGRA8888")) {
         m_internalFormat = m_externalFormat = GL_BGRA;
+#ifdef Q_OS_IOS
+    } else if (strstr(ext, "GL_APPLE_texture_format_BGRA8888")) {
+        m_internalFormat = GL_RGBA;
+        m_externalFormat = GL_BGRA;
+#endif
     } else {
         m_internalFormat = m_externalFormat = GL_RGBA;
     }
@@ -153,13 +168,21 @@ Atlas::Atlas(const QSize &size)
 
 Atlas::~Atlas()
 {
-    if (m_texture_id)
-        glDeleteTextures(1, &m_texture_id);
+    Q_ASSERT(!m_texture_id);
 }
 
+void Atlas::invalidate()
+{
+    Q_ASSERT(QOpenGLContext::currentContext());
+    if (m_texture_id) {
+        glDeleteTextures(1, &m_texture_id);
+        m_texture_id = 0;
+    }
+}
 
 Texture *Atlas::create(const QImage &image)
 {
+    // No need to lock, as manager already locked it.
     QRect rect = m_allocator.allocate(QSize(image.width() + 2, image.height() + 2));
     if (rect.width() > 0 && rect.height() > 0) {
         Texture *t = new Texture(this, rect, image);
@@ -293,6 +316,9 @@ bool Atlas::bind(QSGTexture::Filtering filtering)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+#if !defined(QT_OPENGL_ES_2)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+#endif
         glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_size.width(), m_size.height(), 0, m_externalFormat, GL_UNSIGNED_BYTE, 0);
 
 #if 0
@@ -383,7 +409,6 @@ void Atlas::remove(Texture *t)
 {
     QRect atlasRect = t->atlasSubRect();
     m_allocator.deallocate(atlasRect);
-
     m_pending_uploads.removeOne(t);
 }
 
@@ -428,3 +453,5 @@ QSGTexture *Texture::removedFromAtlas() const
 }
 
 }
+
+QT_END_NAMESPACE
diff --git a/src/quick/scenegraph/util/qsgatlastexture_p.h b/src/quick/scenegraph/util/qsgatlastexture_p.h
index f8edd96f47..ade7b8f00e 100644
--- a/src/quick/scenegraph/util/qsgatlastexture_p.h
+++ b/src/quick/scenegraph/util/qsgatlastexture_p.h
@@ -50,6 +50,8 @@
 #include <QtQuick/private/qsgtexture_p.h>
 #include <QtQuick/private/qsgareaallocator_p.h>
 
+QT_BEGIN_NAMESPACE
+
 namespace QSGAtlasTexture
 {
 
@@ -69,19 +71,18 @@ public:
 
 private:
     Atlas *m_atlas;
-    Atlas *m_secondary_atlas;
 
     QSize m_atlas_size;
     int m_atlas_size_limit;
 };
 
-class Atlas
+class Atlas : public QObject
 {
 public:
     Atlas(const QSize &size);
     ~Atlas();
 
-    void initialize();
+    void invalidate();
 
     int textureId() const;
     bool bind(QSGTexture::Filtering filteing);
@@ -95,7 +96,6 @@ public:
     QSize size() const { return m_size; }
 
 private:
-
     QSGAreaAllocator m_allocator;
     GLuint m_texture_id;
     QSize m_size;
@@ -153,4 +153,6 @@ private:
 
 }
 
+QT_END_NAMESPACE
+
 #endif
diff --git a/src/quick/scenegraph/util/qsgflatcolormaterial.cpp b/src/quick/scenegraph/util/qsgflatcolormaterial.cpp
index 83264e2930..c603c62a20 100644
--- a/src/quick/scenegraph/util/qsgflatcolormaterial.cpp
+++ b/src/quick/scenegraph/util/qsgflatcolormaterial.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qsgflatcolormaterial.h"
+#include <private/qsgmaterialshader_p.h>
 
 #include <qopenglshaderprogram.h>
 
@@ -48,6 +49,8 @@ QT_BEGIN_NAMESPACE
 class FlatColorMaterialShader : public QSGMaterialShader
 {
 public:
+    FlatColorMaterialShader();
+
     virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
     virtual char const *const *attributeNames() const;
 
@@ -55,8 +58,6 @@ public:
 
 private:
     virtual void initialize();
-    virtual const char *vertexShader() const;
-    virtual const char *fragmentShader() const;
 
     int m_matrix_id;
     int m_color_id;
@@ -64,6 +65,13 @@ private:
 
 QSGMaterialType FlatColorMaterialShader::type;
 
+FlatColorMaterialShader::FlatColorMaterialShader()
+    : QSGMaterialShader(*new QSGMaterialShaderPrivate)
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/scenegraph/shaders/flatcolor.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/scenegraph/shaders/flatcolor.frag"));
+}
+
 void FlatColorMaterialShader::updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
 {
     Q_ASSERT(oldEffect == 0 || newEffect->type() == oldEffect->type());
@@ -98,23 +106,6 @@ void FlatColorMaterialShader::initialize()
     m_color_id = program()->uniformLocation("color");
 }
 
-const char *FlatColorMaterialShader::vertexShader() const {
-    return
-        "attribute highp vec4 vCoord;                   \n"
-        "uniform highp mat4 matrix;                     \n"
-        "void main() {                                  \n"
-        "    gl_Position = matrix * vCoord;             \n"
-        "}";
-}
-
-const char *FlatColorMaterialShader::fragmentShader() const {
-    return
-        "uniform lowp vec4 color;                       \n"
-        "void main() {                                  \n"
-        "    gl_FragColor = color;                      \n"
-        "}";
-}
-
 
 
 /*!
diff --git a/src/quick/scenegraph/util/qsgpainternode.cpp b/src/quick/scenegraph/util/qsgpainternode.cpp
index d6bec550d3..797fc4d145 100644
--- a/src/quick/scenegraph/util/qsgpainternode.cpp
+++ b/src/quick/scenegraph/util/qsgpainternode.cpp
@@ -111,7 +111,7 @@ QSGPainterNode::QSGPainterNode(QQuickPaintedItem *item)
     , m_dirtyRenderTarget(false)
     , m_dirtyTexture(false)
 {
-    m_context = static_cast<QQuickPaintedItemPrivate *>(QObjectPrivate::get(item))->sceneGraphContext();
+    m_context = static_cast<QQuickPaintedItemPrivate *>(QObjectPrivate::get(item))->sceneGraphRenderContext();
 
     setMaterial(&m_materialO);
     setOpaqueMaterial(&m_material);
@@ -260,7 +260,7 @@ void QSGPainterNode::updateRenderTarget()
 
     if (m_actualRenderTarget == QQuickPaintedItem::FramebufferObject ||
             m_actualRenderTarget == QQuickPaintedItem::InvertedYFramebufferObject) {
-        const QOpenGLContext *ctx = m_context->glContext();
+        const QOpenGLContext *ctx = m_context->openglContext();
         if (m_fbo && !m_dirtyGeometry && (!ctx->format().samples() || !m_multisamplingSupported))
             return;
 
@@ -323,7 +323,7 @@ void QSGPainterNode::updateFBOSize()
         fboWidth = qMax(QT_MINIMUM_DYNAMIC_FBO_SIZE, qt_next_power_of_two(m_size.width()));
         fboHeight = qMax(QT_MINIMUM_DYNAMIC_FBO_SIZE, qt_next_power_of_two(m_size.height()));
     } else {
-        QSize minimumFBOSize = m_context->minimumFBOSize();
+        QSize minimumFBOSize = m_context->sceneGraphContext()->minimumFBOSize();
         fboWidth = qMax(minimumFBOSize.width(), m_size.width());
         fboHeight = qMax(minimumFBOSize.height(), m_size.height());
     }
diff --git a/src/quick/scenegraph/util/qsgpainternode_p.h b/src/quick/scenegraph/util/qsgpainternode_p.h
index bc1556672c..df0943d38e 100644
--- a/src/quick/scenegraph/util/qsgpainternode_p.h
+++ b/src/quick/scenegraph/util/qsgpainternode_p.h
@@ -113,7 +113,7 @@ private:
     void updateRenderTarget();
     void updateFBOSize();
 
-    QSGContext *m_context;
+    QSGRenderContext *m_context;
 
     QQuickPaintedItem::RenderTarget m_preferredRenderTarget;
     QQuickPaintedItem::RenderTarget m_actualRenderTarget;
diff --git a/src/quick/scenegraph/util/qsgshadersourcebuilder.cpp b/src/quick/scenegraph/util/qsgshadersourcebuilder.cpp
new file mode 100644
index 0000000000..1a1963dbca
--- /dev/null
+++ b/src/quick/scenegraph/util/qsgshadersourcebuilder.cpp
@@ -0,0 +1,403 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, 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.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsgshadersourcebuilder_p.h"
+
+#include <QtGui/qopenglcontext.h>
+#include <QtGui/qopenglshaderprogram.h>
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QSGShaderParser {
+
+struct Tokenizer {
+
+    enum Token {
+        Token_Invalid,
+        Token_Void,
+        Token_OpenBrace,
+        Token_CloseBrace,
+        Token_SemiColon,
+        Token_Identifier,
+        Token_Macro,
+        Token_Version,
+        Token_Extension,
+        Token_SingleLineComment,
+        Token_MultiLineCommentStart,
+        Token_MultiLineCommentEnd,
+        Token_NewLine,
+        Token_Unspecified,
+        Token_EOF
+    };
+
+    static const char *NAMES[];
+
+    void initialize(const char *input);
+    Token next();
+
+    const char *stream;
+    const char *pos;
+    const char *identifier;
+};
+
+const char *Tokenizer::NAMES[] = {
+    "Invalid",
+    "Void",
+    "OpenBrace",
+    "CloseBrace",
+    "SemiColon",
+    "Identifier",
+    "Macro",
+    "Version",
+    "Extension",
+    "SingleLineComment",
+    "MultiLineCommentStart",
+    "MultiLineCommentEnd",
+    "NewLine",
+    "Unspecified",
+    "EOF"
+};
+
+void Tokenizer::initialize(const char *input)
+{
+    stream = input;
+    pos = input;
+    identifier = input;
+}
+
+Tokenizer::Token Tokenizer::next()
+{
+    while (*pos != 0) {
+        char c = *pos++;
+        switch (c) {
+        case '/':
+            if (*pos == '/') {
+                // '//' comment
+                return Token_SingleLineComment;
+            } else if (*pos == '*') {
+                // /* */ comment
+                return Token_MultiLineCommentStart;
+            }
+            break;
+
+        case '*':
+            if (*pos == '/')
+                return Token_MultiLineCommentEnd;
+
+        case '\n':
+            return Token_NewLine;
+
+        case '\r':
+            if (*pos == '\n')
+                return Token_NewLine;
+
+        case '#': {
+            if (*pos == 'v' && pos[1] == 'e' && pos[2] == 'r' && pos[3] == 's'
+                && pos[4] == 'i' && pos[5] == 'o' && pos[6] == 'n') {
+                return Token_Version;
+            } else if (*pos == 'e' && pos[1] == 'x' && pos[2] == 't' && pos[3] == 'e'
+                       && pos[4] == 'n' && pos[5] == 's' && pos[6] == 'i'&& pos[7] == 'o'
+                       && pos[8] == 'n') {
+                return Token_Extension;
+            } else {
+                while (*pos != 0) {
+                    if (*pos == '\n') {
+                        ++pos;
+                        break;
+                    } else if (*pos == '\\') {
+                        ++pos;
+                        while (*pos != 0 && (*pos == ' ' || *pos == '\t'))
+                            ++pos;
+                        if (*pos != 0 && (*pos == '\n' || (*pos == '\r' && pos[1] == '\n')))
+                            pos+=2;
+                    } else {
+                        ++pos;
+                    }
+                }
+            }
+            break;
+        }
+
+        case ';':
+            return Token_SemiColon;
+
+        case 0:
+            return Token_EOF;
+
+        case '{':
+            return Token_OpenBrace;
+
+        case '}':
+            return Token_CloseBrace;
+
+        case ' ':
+            break;
+
+        case 'v': {
+            if (*pos == 'o' && pos[1] == 'i' && pos[2] == 'd') {
+                pos += 3;
+                return Token_Void;
+            }
+            // Fall-thru
+        }
+        default:
+            // Identifier...
+            if ((c >= 'a' && c <= 'z' ) || (c >= 'A' && c <= 'Z' ) || c == '_') {
+                identifier = pos - 1;
+                while (*pos != 0 && ((*pos >= 'a' && *pos <= 'z')
+                                     || (*pos >= 'A' && *pos <= 'Z')
+                                     || *pos == '_'
+                                     || (*pos >= '0' && *pos <= '9'))) {
+                    ++pos;
+                }
+                return Token_Identifier;
+            } else {
+                return Token_Unspecified;
+            }
+        }
+    }
+
+    return Token_Invalid;
+}
+
+} // namespace QSGShaderParser
+
+using namespace QSGShaderParser;
+
+QSGShaderSourceBuilder::QSGShaderSourceBuilder()
+{
+}
+
+void QSGShaderSourceBuilder::initializeProgramFromFiles(QOpenGLShaderProgram *program,
+                                                        const QString &vertexShader,
+                                                        const QString &fragmentShader)
+{
+    Q_ASSERT(program);
+    program->removeAllShaders();
+
+    QSGShaderSourceBuilder builder;
+
+    builder.appendSourceFile(vertexShader);
+    program->addShaderFromSourceCode(QOpenGLShader::Vertex, builder.source());
+    builder.clear();
+
+    builder.appendSourceFile(fragmentShader);
+    program->addShaderFromSourceCode(QOpenGLShader::Fragment, builder.source());
+}
+
+QByteArray QSGShaderSourceBuilder::source() const
+{
+    return m_source;
+}
+
+void QSGShaderSourceBuilder::clear()
+{
+    m_source.clear();
+}
+
+void QSGShaderSourceBuilder::appendSource(const QByteArray &source)
+{
+    m_source += source;
+}
+
+void QSGShaderSourceBuilder::appendSourceFile(const QString &fileName)
+{
+    const QString resolvedFileName = resolveShaderPath(fileName);
+    QFile f(resolvedFileName);
+    if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qWarning() << "Failed to find shader" << resolvedFileName;
+        return;
+    }
+    m_source += f.readAll();
+}
+
+void QSGShaderSourceBuilder::addDefinition(const QByteArray &definition)
+{
+    if (definition.isEmpty())
+        return;
+
+    Tokenizer tok;
+    const char *input = m_source.constData();
+    tok.initialize(input);
+
+    // First find #version, #extension's and "void main() { ... "
+    const char *versionPos = 0;
+    const char *extensionPos = 0;
+    bool inSingleLineComment = false;
+    bool inMultiLineComment = false;
+    bool foundVersionStart = false;
+    bool foundExtensionStart = false;
+
+    Tokenizer::Token lt = Tokenizer::Token_Unspecified;
+    Tokenizer::Token t = tok.next();
+    while (t != Tokenizer::Token_EOF) {
+        // Handle comment blocks
+        if (t == Tokenizer::Token_MultiLineCommentStart )
+            inMultiLineComment = true;
+        if (t == Tokenizer::Token_MultiLineCommentEnd)
+            inMultiLineComment = false;
+        if (t == Tokenizer::Token_SingleLineComment)
+            inSingleLineComment = true;
+        if (t == Tokenizer::Token_NewLine && inSingleLineComment && !inMultiLineComment)
+            inSingleLineComment = false;
+
+        // Have we found #version, #extension or void main()?
+        if (t == Tokenizer::Token_Version && !inSingleLineComment && !inMultiLineComment)
+            foundVersionStart = true;
+
+        if (t == Tokenizer::Token_Extension && !inSingleLineComment && !inMultiLineComment)
+            foundExtensionStart = true;
+
+        if (foundVersionStart && t == Tokenizer::Token_NewLine) {
+            versionPos = tok.pos;
+            foundVersionStart = false;
+        } else if (foundExtensionStart && t == Tokenizer::Token_NewLine) {
+            extensionPos = tok.pos;
+            foundExtensionStart = false;
+        } else if (lt == Tokenizer::Token_Void && t == Tokenizer::Token_Identifier) {
+            if (qstrncmp("main", tok.identifier, 4) == 0)
+                break;
+        }
+
+        // Scan to next token
+        lt = t;
+        t = tok.next();
+    }
+
+    // Determine where to insert the definition.
+    // If we found #extension directives, insert after last one,
+    // else, if we found #version insert after #version
+    // otherwise, insert at beginning.
+    const char *insertionPos = extensionPos ? extensionPos : (versionPos ? versionPos : input);
+
+    // Construct a new shader string, inserting the definition
+    QByteArray newSource;
+    newSource.reserve(m_source.size() + definition.size() + 9);
+    newSource += QByteArray::fromRawData(input, insertionPos - input);
+    newSource += QByteArrayLiteral("#define ") + definition + QByteArrayLiteral("\n");
+    newSource += QByteArray::fromRawData(insertionPos, m_source.size() - (insertionPos - input));
+
+    m_source = newSource;
+}
+
+void QSGShaderSourceBuilder::removeVersion()
+{
+    Tokenizer tok;
+    const char *input = m_source.constData();
+    tok.initialize(input);
+
+    // First find #version beginning and end (if present)
+    const char *versionStartPos = 0;
+    const char *versionEndPos = 0;
+    bool inSingleLineComment = false;
+    bool inMultiLineComment = false;
+    bool foundVersionStart = false;
+
+    Tokenizer::Token lt = Tokenizer::Token_Unspecified;
+    Tokenizer::Token t = tok.next();
+    while (t != Tokenizer::Token_EOF) {
+        // Handle comment blocks
+        if (t == Tokenizer::Token_MultiLineCommentStart )
+            inMultiLineComment = true;
+        if (t == Tokenizer::Token_MultiLineCommentEnd)
+            inMultiLineComment = false;
+        if (t == Tokenizer::Token_SingleLineComment)
+            inSingleLineComment = true;
+        if (t == Tokenizer::Token_NewLine && inSingleLineComment && !inMultiLineComment)
+            inSingleLineComment = false;
+
+        // Have we found #version, #extension or void main()?
+        if (t == Tokenizer::Token_Version && !inSingleLineComment && !inMultiLineComment) {
+            versionStartPos = tok.pos - 1;
+            foundVersionStart = true;
+        } else if (foundVersionStart && t == Tokenizer::Token_NewLine) {
+            versionEndPos = tok.pos;
+            break;
+        } else if (lt == Tokenizer::Token_Void && t == Tokenizer::Token_Identifier) {
+            if (qstrncmp("main", tok.identifier, 4) == 0)
+                break;
+        }
+
+        // Scan to next token
+        lt = t;
+        t = tok.next();
+    }
+
+    if (versionStartPos == 0)
+        return;
+
+    // Construct a new shader string, inserting the definition
+    QByteArray newSource;
+    newSource.reserve(m_source.size() - (versionEndPos - versionStartPos));
+    newSource += QByteArray::fromRawData(input, versionStartPos - input);
+    newSource += QByteArray::fromRawData(versionEndPos, m_source.size() - (versionEndPos - versionStartPos));
+
+    m_source = newSource;
+}
+
+QString QSGShaderSourceBuilder::resolveShaderPath(const QString &path) const
+{
+    if (contextProfile() != QSurfaceFormat::CoreProfile) {
+        return path;
+    } else {
+        int idx = path.lastIndexOf(QStringLiteral("."));
+        QString resolvedPath;
+        if (idx != -1)
+            resolvedPath = path.left(idx)
+                         + QStringLiteral("_core")
+                         + path.right(path.length() - idx);
+        return resolvedPath;
+    }
+}
+
+QSurfaceFormat::OpenGLContextProfile QSGShaderSourceBuilder::contextProfile() const
+{
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    QSurfaceFormat::OpenGLContextProfile profile = QSurfaceFormat::NoProfile;
+    Q_ASSERT(context);
+    profile = context->format().profile();
+    return profile;
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/scenegraph/util/qsgshadersourcebuilder_p.h b/src/quick/scenegraph/util/qsgshadersourcebuilder_p.h
new file mode 100644
index 0000000000..63f2d78767
--- /dev/null
+++ b/src/quick/scenegraph/util/qsgshadersourcebuilder_p.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, 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.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSGSHADERSOURCEBUILDER_P_H
+#define QSGSHADERSOURCEBUILDER_P_H
+
+#include <private/qtquickglobal_p.h>
+
+#include <QtGui/qsurfaceformat.h>
+#include <QtCore/qbytearray.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLShaderProgram;
+
+class Q_QUICK_PRIVATE_EXPORT QSGShaderSourceBuilder
+{
+public:
+    QSGShaderSourceBuilder();
+
+    static void initializeProgramFromFiles(QOpenGLShaderProgram *program,
+                                           const QString &vertexShader,
+                                           const QString &fragmentShader);
+
+    QByteArray source() const;
+    void clear();
+
+    void appendSource(const QByteArray &source);
+    void appendSourceFile(const QString &fileName);
+    void addDefinition(const QByteArray &definition);
+    void removeVersion();
+
+protected:
+    virtual QString resolveShaderPath(const QString &path) const;
+
+private:
+    QSurfaceFormat::OpenGLContextProfile contextProfile() const;
+
+    QByteArray m_source;
+};
+
+QT_END_NAMESPACE
+
+#endif // QSGSHADERSOURCEBUILDER_P_H
diff --git a/src/quick/scenegraph/util/qsgtexture.cpp b/src/quick/scenegraph/util/qsgtexture.cpp
index b079100a37..51b3bafaf7 100644
--- a/src/quick/scenegraph/util/qsgtexture.cpp
+++ b/src/quick/scenegraph/util/qsgtexture.cpp
@@ -682,16 +682,21 @@ void QSGPlainTexture::bind()
     GLenum externalFormat = GL_RGBA;
     GLenum internalFormat = GL_RGBA;
 
-    const char *extensions = (const char *) glGetString(GL_EXTENSIONS);
-    if (strstr(extensions, "GL_EXT_bgra")) {
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    if (context->hasExtension(QByteArrayLiteral("GL_EXT_bgra"))) {
         externalFormat = GL_BGRA;
 #ifdef QT_OPENGL_ES
         internalFormat = GL_BGRA;
 #endif
-    } else if (strstr(extensions, "GL_EXT_texture_format_BGRA8888")
-               || strstr(extensions, "GL_IMG_texture_format_BGRA8888")) {
+    } else if (context->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))
+            || context->hasExtension(QByteArrayLiteral("GL_IMG_texture_format_BGRA8888"))) {
         externalFormat = GL_BGRA;
         internalFormat = GL_BGRA;
+#ifdef Q_OS_IOS
+    } else if (context->hasExtension(QByteArrayLiteral("GL_APPLE_texture_format_BGRA8888"))) {
+        externalFormat = GL_BGRA;
+        internalFormat = GL_RGBA;
+#endif
     } else {
         qsg_swizzleBGRAToRGBA(&tmp);
     }
@@ -711,8 +716,7 @@ void QSGPlainTexture::bind()
 
 
     if (m_has_mipmaps) {
-        QOpenGLContext *ctx = QOpenGLContext::currentContext();
-        ctx->functions()->glGenerateMipmap(GL_TEXTURE_2D);
+        context->functions()->glGenerateMipmap(GL_TEXTURE_2D);
         m_mipmaps_generated = true;
     }
 
diff --git a/src/quick/scenegraph/util/qsgtexturematerial.cpp b/src/quick/scenegraph/util/qsgtexturematerial.cpp
index ba98c83682..df55404504 100644
--- a/src/quick/scenegraph/util/qsgtexturematerial.cpp
+++ b/src/quick/scenegraph/util/qsgtexturematerial.cpp
@@ -54,36 +54,15 @@ inline static bool isPowerOfTwo(int x)
 }
 #endif
 
-const char qt_scenegraph_texture_material_vertex_code[] =
-    "uniform highp mat4 qt_Matrix;                      \n"
-    "attribute highp vec4 qt_VertexPosition;            \n"
-    "attribute highp vec2 qt_VertexTexCoord;            \n"
-    "varying highp vec2 qt_TexCoord;                    \n"
-    "void main() {                                      \n"
-    "    qt_TexCoord = qt_VertexTexCoord;               \n"
-    "    gl_Position = qt_Matrix * qt_VertexPosition;   \n"
-    "}";
-
-const char qt_scenegraph_texture_material_fragment[] =
-    "varying highp vec2 qt_TexCoord;                    \n"
-    "uniform sampler2D qt_Texture;                      \n"
-    "void main() {                                      \n"
-    "    gl_FragColor = texture2D(qt_Texture, qt_TexCoord);\n"
-    "}";
-
-
-const char *QSGOpaqueTextureMaterialShader::vertexShader() const
-{
-    return qt_scenegraph_texture_material_vertex_code;
-}
+QSGMaterialType QSGOpaqueTextureMaterialShader::type;
 
-const char *QSGOpaqueTextureMaterialShader::fragmentShader() const
+QSGOpaqueTextureMaterialShader::QSGOpaqueTextureMaterialShader()
+    : QSGMaterialShader()
 {
-    return qt_scenegraph_texture_material_fragment;
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/scenegraph/shaders/opaquetexture.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/scenegraph/shaders/opaquetexture.frag"));
 }
 
-QSGMaterialType QSGOpaqueTextureMaterialShader::type;
-
 char const *const *QSGOpaqueTextureMaterialShader::attributeNames() const
 {
     static char const *const attr[] = { "qt_VertexPosition", "qt_VertexTexCoord", 0 };
@@ -353,14 +332,6 @@ int QSGOpaqueTextureMaterial::compare(const QSGMaterial *o) const
     a material in the scene graph.
  */
 
-static const char qt_scenegraph_texture_material_opacity_fragment[] =
-    "varying highp vec2 qt_TexCoord;                       \n"
-    "uniform sampler2D qt_Texture;                         \n"
-    "uniform lowp float opacity;                        \n"
-    "void main() {                                      \n"
-    "    gl_FragColor = texture2D(qt_Texture, qt_TexCoord) * opacity; \n"
-    "}";
-
 QSGMaterialType QSGTextureMaterialShader::type;
 
 
@@ -385,6 +356,12 @@ QSGMaterialShader *QSGTextureMaterial::createShader() const
     return new QSGTextureMaterialShader;
 }
 
+QSGTextureMaterialShader::QSGTextureMaterialShader()
+    : QSGOpaqueTextureMaterialShader()
+{
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/scenegraph/shaders/texture.frag"));
+}
+
 void QSGTextureMaterialShader::updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
 {
     Q_ASSERT(oldEffect == 0 || newEffect->type() == oldEffect->type());
@@ -400,9 +377,4 @@ void QSGTextureMaterialShader::initialize()
     m_opacity_id = program()->uniformLocation("opacity");
 }
 
-const char *QSGTextureMaterialShader::fragmentShader() const
-{
-    return qt_scenegraph_texture_material_opacity_fragment;
-}
-
 QT_END_NAMESPACE
diff --git a/src/quick/scenegraph/util/qsgtexturematerial_p.h b/src/quick/scenegraph/util/qsgtexturematerial_p.h
index 077337d211..db65d85738 100644
--- a/src/quick/scenegraph/util/qsgtexturematerial_p.h
+++ b/src/quick/scenegraph/util/qsgtexturematerial_p.h
@@ -50,6 +50,8 @@ QT_BEGIN_NAMESPACE
 class Q_QUICK_PRIVATE_EXPORT QSGOpaqueTextureMaterialShader : public QSGMaterialShader
 {
 public:
+    QSGOpaqueTextureMaterialShader();
+
     virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
     virtual char const *const *attributeNames() const;
 
@@ -57,8 +59,6 @@ public:
 
 protected:
     virtual void initialize();
-    virtual const char *vertexShader() const;
-    virtual const char *fragmentShader() const;
 
     int m_matrix_id;
 };
@@ -66,14 +66,14 @@ protected:
 class QSGTextureMaterialShader : public QSGOpaqueTextureMaterialShader
 {
 public:
+    QSGTextureMaterialShader();
+
     virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
     virtual void initialize();
 
     static QSGMaterialType type;
 
 protected:
-    virtual const char *fragmentShader() const;
-
     int m_opacity_id;
 };
 
diff --git a/src/quick/scenegraph/util/qsgvertexcolormaterial.cpp b/src/quick/scenegraph/util/qsgvertexcolormaterial.cpp
index f205f34ce4..ef2455f702 100644
--- a/src/quick/scenegraph/util/qsgvertexcolormaterial.cpp
+++ b/src/quick/scenegraph/util/qsgvertexcolormaterial.cpp
@@ -48,6 +48,8 @@ QT_BEGIN_NAMESPACE
 class QSGVertexColorMaterialShader : public QSGMaterialShader
 {
 public:
+    QSGVertexColorMaterialShader();
+
     virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
     virtual char const *const *attributeNames() const;
 
@@ -55,8 +57,6 @@ public:
 
 private:
     virtual void initialize();
-    virtual const char *vertexShader() const;
-    virtual const char *fragmentShader() const;
 
     int m_matrix_id;
     int m_opacity_id;
@@ -64,6 +64,13 @@ private:
 
 QSGMaterialType QSGVertexColorMaterialShader::type;
 
+QSGVertexColorMaterialShader::QSGVertexColorMaterialShader()
+    : QSGMaterialShader()
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/scenegraph/shaders/vertexcolor.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/scenegraph/shaders/vertexcolor.frag"));
+}
+
 void QSGVertexColorMaterialShader::updateState(const RenderState &state, QSGMaterial * /*newEffect*/, QSGMaterial *)
 {
     if (state.isOpacityDirty())
@@ -85,28 +92,6 @@ void QSGVertexColorMaterialShader::initialize()
     m_opacity_id = program()->uniformLocation("opacity");
 }
 
-const char *QSGVertexColorMaterialShader::vertexShader() const {
-    return
-        "attribute highp vec4 vertexCoord;              \n"
-        "attribute highp vec4 vertexColor;              \n"
-        "uniform highp mat4 matrix;                     \n"
-        "uniform highp float opacity;                   \n"
-        "varying lowp vec4 color;                       \n"
-        "void main() {                                  \n"
-        "    gl_Position = matrix * vertexCoord;        \n"
-        "    color = vertexColor * opacity;             \n"
-        "}";
-}
-
-const char *QSGVertexColorMaterialShader::fragmentShader() const {
-    return
-        "varying lowp vec4 color;                       \n"
-        "void main() {                                  \n"
-        "    gl_FragColor = color;                      \n"
-        "}";
-}
-
-
 
 /*!
     \class QSGVertexColorMaterial