Move shadergraph to Qt3D

Change-Id: I3ed10747175a58513933b29eac66ddf92fe87d07
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

17 files changed, 2896 insertions, 0 deletions

diff --git a/src/render/shadergraph/qshaderformat.cpp b/src/render/shadergraph/qshaderformat.cpp
new file mode 100644
index 000000000..98643fb24
--- /dev/null
+++ b/src/render/shadergraph/qshaderformat.cpp
@@ -0,0 +1,146 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshaderformat_p.h"
+
+QT_BEGIN_NAMESPACE
+namespace Qt3DRender
+{
+QShaderFormat::QShaderFormat() noexcept
+    : m_api(NoApi)
+    , m_shaderType(Fragment)
+{
+}
+
+QShaderFormat::Api QShaderFormat::api() const noexcept
+{
+    return m_api;
+}
+
+void QShaderFormat::setApi(QShaderFormat::Api api) noexcept
+{
+    m_api = api;
+}
+
+QVersionNumber QShaderFormat::version() const noexcept
+{
+    return m_version;
+}
+
+void QShaderFormat::setVersion(const QVersionNumber &version) noexcept
+{
+    m_version = version;
+}
+
+QStringList QShaderFormat::extensions() const noexcept
+{
+    return m_extensions;
+}
+
+void QShaderFormat::setExtensions(const QStringList &extensions) noexcept
+{
+    m_extensions = extensions;
+    m_extensions.sort();
+}
+
+QString QShaderFormat::vendor() const noexcept
+{
+    return m_vendor;
+}
+
+void QShaderFormat::setVendor(const QString &vendor) noexcept
+{
+    m_vendor = vendor;
+}
+
+bool QShaderFormat::isValid() const noexcept
+{
+    return m_api != NoApi && m_version.majorVersion() > 0;
+}
+
+bool QShaderFormat::supports(const QShaderFormat &other) const noexcept
+{
+    if (!isValid() || !other.isValid())
+        return false;
+
+    if (m_api == OpenGLES && m_api != other.m_api)
+        return false;
+
+    if (m_api == OpenGLCoreProfile && m_api != other.m_api)
+        return false;
+
+    if (m_version < other.m_version)
+        return false;
+
+    if (m_shaderType != other.m_shaderType)
+        return false;
+
+    const auto containsAllExtensionsFromOther = std::includes(m_extensions.constBegin(),
+                                                              m_extensions.constEnd(),
+                                                              other.m_extensions.constBegin(),
+                                                              other.m_extensions.constEnd());
+    if (!containsAllExtensionsFromOther)
+        return false;
+
+    if (!other.m_vendor.isEmpty() && m_vendor != other.m_vendor)
+        return false;
+
+    return true;
+}
+
+QShaderFormat::ShaderType QShaderFormat::shaderType() const Q_DECL_NOTHROW
+{
+    return m_shaderType;
+}
+
+void QShaderFormat::setShaderType(QShaderFormat::ShaderType shaderType) Q_DECL_NOTHROW
+{
+    m_shaderType = shaderType;
+}
+
+bool operator==(const QShaderFormat &lhs, const QShaderFormat &rhs) noexcept
+{
+    return lhs.api() == rhs.api()
+        && lhs.version() == rhs.version()
+        && lhs.extensions() == rhs.extensions()
+        && lhs.vendor() == rhs.vendor()
+        && lhs.shaderType() == rhs.shaderType();
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshaderformat_p.h b/src/render/shadergraph/qshaderformat_p.h
new file mode 100644
index 000000000..ad9898bd0
--- /dev/null
+++ b/src/render/shadergraph/qshaderformat_p.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERFORMAT_P_H
+#define QT3DRENDER_QSHADERFORMAT_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <QtCore/qstringlist.h>
+#include <QtCore/qversionnumber.h>
+
+QT_BEGIN_NAMESPACE
+namespace Qt3DRender
+{
+class QShaderFormat
+{
+public:
+    enum Api : int {
+        NoApi,
+        OpenGLNoProfile,
+        OpenGLCoreProfile,
+        OpenGLCompatibilityProfile,
+        OpenGLES,
+        VulkanFlavoredGLSL,
+        RHI
+    };
+
+    enum ShaderType : int {
+        Vertex = 0,
+        TessellationControl,
+        TessellationEvaluation,
+        Geometry,
+        Fragment,
+        Compute
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QShaderFormat() noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT Api api() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setApi(Api api) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVersionNumber version() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setVersion(const QVersionNumber &version) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QStringList extensions() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setExtensions(const QStringList &extensions) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QString vendor() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setVendor(const QString &vendor) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT bool isValid() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT bool supports(const QShaderFormat &other) const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT ShaderType shaderType() const Q_DECL_NOTHROW;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setShaderType(ShaderType shaderType) Q_DECL_NOTHROW;
+
+private:
+    Api m_api;
+    QVersionNumber m_version;
+    QStringList m_extensions;
+    QString m_vendor;
+    ShaderType m_shaderType;
+};
+
+Q_3DRENDERSHARED_PRIVATE_EXPORT bool operator==(const QShaderFormat &lhs, const QShaderFormat &rhs) noexcept;
+
+inline bool operator!=(const QShaderFormat &lhs, const QShaderFormat &rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+
+}
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderFormat, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderFormat)
+
+#endif // QT3DRENDER_QSHADERFORMAT_P_H
diff --git a/src/render/shadergraph/qshadergenerator.cpp b/src/render/shadergraph/qshadergenerator.cpp
new file mode 100644
index 000000000..4f37cfef1
--- /dev/null
+++ b/src/render/shadergraph/qshadergenerator.cpp
@@ -0,0 +1,640 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadergenerator_p.h"
+
+#include "qshaderlanguage_p.h"
+#include <QRegularExpression>
+
+#include <cctype>
+
+QT_BEGIN_NAMESPACE
+namespace Qt3DRender
+{
+Q_LOGGING_CATEGORY(ShaderGenerator, "ShaderGenerator", QtWarningMsg)
+
+namespace
+{
+    QByteArray toGlsl(QShaderLanguage::StorageQualifier qualifier, const QShaderFormat &format)
+    {
+        if (format.version().majorVersion() <= 2) {
+            // Note we're assuming fragment shader only here, it'd be different
+            // values for vertex shader, will need to be fixed properly at some
+            // point but isn't necessary yet (this problem already exists in past
+            // commits anyway)
+            switch (qualifier) {
+            case QShaderLanguage::Const:
+                return "const";
+            case QShaderLanguage::Input:
+                if (format.shaderType() == QShaderFormat::Vertex)
+                    return "attribute";
+                else
+                    return "varying";
+            case QShaderLanguage::Output:
+                return ""; // Although fragment shaders for <=2 only have fixed outputs
+            case QShaderLanguage::Uniform:
+                return "uniform";
+            case QShaderLanguage::BuiltIn:
+                return "//";
+            }
+        } else {
+            switch (qualifier) {
+            case QShaderLanguage::Const:
+                return "const";
+            case QShaderLanguage::Input:
+                return "in";
+            case QShaderLanguage::Output:
+                return "out";
+            case QShaderLanguage::Uniform:
+                return "uniform";
+            case QShaderLanguage::BuiltIn:
+                return "//";
+            }
+        }
+
+        Q_UNREACHABLE();
+    }
+
+    QByteArray toGlsl(QShaderLanguage::VariableType type)
+    {
+        switch (type) {
+        case QShaderLanguage::Bool:
+            return "bool";
+        case QShaderLanguage::Int:
+            return "int";
+        case QShaderLanguage::Uint:
+            return "uint";
+        case QShaderLanguage::Float:
+            return "float";
+        case QShaderLanguage::Double:
+            return "double";
+        case QShaderLanguage::Vec2:
+            return "vec2";
+        case QShaderLanguage::Vec3:
+            return "vec3";
+        case QShaderLanguage::Vec4:
+            return "vec4";
+        case QShaderLanguage::DVec2:
+            return "dvec2";
+        case QShaderLanguage::DVec3:
+            return "dvec3";
+        case QShaderLanguage::DVec4:
+            return "dvec4";
+        case QShaderLanguage::BVec2:
+            return "bvec2";
+        case QShaderLanguage::BVec3:
+            return "bvec3";
+        case QShaderLanguage::BVec4:
+            return "bvec4";
+        case QShaderLanguage::IVec2:
+            return "ivec2";
+        case QShaderLanguage::IVec3:
+            return "ivec3";
+        case QShaderLanguage::IVec4:
+            return "ivec4";
+        case QShaderLanguage::UVec2:
+            return "uvec2";
+        case QShaderLanguage::UVec3:
+            return "uvec3";
+        case QShaderLanguage::UVec4:
+            return "uvec4";
+        case QShaderLanguage::Mat2:
+            return "mat2";
+        case QShaderLanguage::Mat3:
+            return "mat3";
+        case QShaderLanguage::Mat4:
+            return "mat4";
+        case QShaderLanguage::Mat2x2:
+            return "mat2x2";
+        case QShaderLanguage::Mat2x3:
+            return "mat2x3";
+        case QShaderLanguage::Mat2x4:
+            return "mat2x4";
+        case QShaderLanguage::Mat3x2:
+            return "mat3x2";
+        case QShaderLanguage::Mat3x3:
+            return "mat3x3";
+        case QShaderLanguage::Mat3x4:
+            return "mat3x4";
+        case QShaderLanguage::Mat4x2:
+            return "mat4x2";
+        case QShaderLanguage::Mat4x3:
+            return "mat4x3";
+        case QShaderLanguage::Mat4x4:
+            return "mat4x4";
+        case QShaderLanguage::DMat2:
+            return "dmat2";
+        case QShaderLanguage::DMat3:
+            return "dmat3";
+        case QShaderLanguage::DMat4:
+            return "dmat4";
+        case QShaderLanguage::DMat2x2:
+            return "dmat2x2";
+        case QShaderLanguage::DMat2x3:
+            return "dmat2x3";
+        case QShaderLanguage::DMat2x4:
+            return "dmat2x4";
+        case QShaderLanguage::DMat3x2:
+            return "dmat3x2";
+        case QShaderLanguage::DMat3x3:
+            return "dmat3x3";
+        case QShaderLanguage::DMat3x4:
+            return "dmat3x4";
+        case QShaderLanguage::DMat4x2:
+            return "dmat4x2";
+        case QShaderLanguage::DMat4x3:
+            return "dmat4x3";
+        case QShaderLanguage::DMat4x4:
+            return "dmat4x4";
+        case QShaderLanguage::Sampler1D:
+            return "sampler1D";
+        case QShaderLanguage::Sampler2D:
+            return "sampler2D";
+        case QShaderLanguage::Sampler3D:
+            return "sampler3D";
+        case QShaderLanguage::SamplerCube:
+            return "samplerCube";
+        case QShaderLanguage::Sampler2DRect:
+            return "sampler2DRect";
+        case QShaderLanguage::Sampler2DMs:
+            return "sampler2DMS";
+        case QShaderLanguage::SamplerBuffer:
+            return "samplerBuffer";
+        case QShaderLanguage::Sampler1DArray:
+            return "sampler1DArray";
+        case QShaderLanguage::Sampler2DArray:
+            return "sampler2DArray";
+        case QShaderLanguage::Sampler2DMsArray:
+            return "sampler2DMSArray";
+        case QShaderLanguage::SamplerCubeArray:
+            return "samplerCubeArray";
+        case QShaderLanguage::Sampler1DShadow:
+            return "sampler1DShadow";
+        case QShaderLanguage::Sampler2DShadow:
+            return "sampler2DShadow";
+        case QShaderLanguage::Sampler2DRectShadow:
+            return "sampler2DRectShadow";
+        case QShaderLanguage::Sampler1DArrayShadow:
+            return "sampler1DArrayShadow";
+        case QShaderLanguage::Sampler2DArrayShadow:
+            return "sample2DArrayShadow";
+        case QShaderLanguage::SamplerCubeShadow:
+            return "samplerCubeShadow";
+        case QShaderLanguage::SamplerCubeArrayShadow:
+            return "samplerCubeArrayShadow";
+        case QShaderLanguage::ISampler1D:
+            return "isampler1D";
+        case QShaderLanguage::ISampler2D:
+            return "isampler2D";
+        case QShaderLanguage::ISampler3D:
+            return "isampler3D";
+        case QShaderLanguage::ISamplerCube:
+            return "isamplerCube";
+        case QShaderLanguage::ISampler2DRect:
+            return "isampler2DRect";
+        case QShaderLanguage::ISampler2DMs:
+            return "isampler2DMS";
+        case QShaderLanguage::ISamplerBuffer:
+            return "isamplerBuffer";
+        case QShaderLanguage::ISampler1DArray:
+            return "isampler1DArray";
+        case QShaderLanguage::ISampler2DArray:
+            return "isampler2DArray";
+        case QShaderLanguage::ISampler2DMsArray:
+            return "isampler2DMSArray";
+        case QShaderLanguage::ISamplerCubeArray:
+            return "isamplerCubeArray";
+        case QShaderLanguage::USampler1D:
+            return "usampler1D";
+        case QShaderLanguage::USampler2D:
+            return "usampler2D";
+        case QShaderLanguage::USampler3D:
+            return "usampler3D";
+        case QShaderLanguage::USamplerCube:
+            return "usamplerCube";
+        case QShaderLanguage::USampler2DRect:
+            return "usampler2DRect";
+        case QShaderLanguage::USampler2DMs:
+            return "usampler2DMS";
+        case QShaderLanguage::USamplerBuffer:
+            return "usamplerBuffer";
+        case QShaderLanguage::USampler1DArray:
+            return "usampler1DArray";
+        case QShaderLanguage::USampler2DArray:
+            return "usampler2DArray";
+        case QShaderLanguage::USampler2DMsArray:
+            return "usampler2DMSArray";
+        case QShaderLanguage::USamplerCubeArray:
+            return "usamplerCubeArray";
+        }
+
+        Q_UNREACHABLE();
+    }
+
+    QByteArray replaceParameters(const QByteArray &original, const QShaderNode &node, const QShaderFormat &format)
+    {
+        QByteArray result = original;
+
+        const QStringList parameterNames = node.parameterNames();
+        for (const QString &parameterName : parameterNames) {
+            const QByteArray placeholder = QByteArray(QByteArrayLiteral("$") + parameterName.toUtf8());
+            const QVariant parameter = node.parameter(parameterName);
+            if (parameter.userType() == qMetaTypeId<QShaderLanguage::StorageQualifier>()) {
+                const QShaderLanguage::StorageQualifier qualifier = qvariant_cast<QShaderLanguage::StorageQualifier>(parameter);
+                const QByteArray value = toGlsl(qualifier, format);
+                result.replace(placeholder, value);
+            } else if (parameter.userType() == qMetaTypeId<QShaderLanguage::VariableType>()) {
+                const QShaderLanguage::VariableType type = qvariant_cast<QShaderLanguage::VariableType>(parameter);
+                const QByteArray value = toGlsl(type);
+                result.replace(placeholder, value);
+            } else {
+                const QByteArray value = parameter.toString().toUtf8();
+                result.replace(placeholder, value);
+            }
+        }
+
+        return result;
+    }
+}
+
+QByteArray QShaderGenerator::createShaderCode(const QStringList &enabledLayers) const
+{
+    auto code = QByteArrayList();
+
+    if (format.isValid()) {
+        const bool isGLES = format.api() == QShaderFormat::OpenGLES;
+        const int major = format.version().majorVersion();
+        const int minor = format.version().minorVersion();
+
+        const int version = major == 2 && isGLES ? 100
+                          : major == 3 && isGLES ? 300
+                          : major == 2 ? 100 + 10 * (minor + 1)
+                          : major == 3 && minor <= 2 ? 100 + 10 * (minor + 3)
+                          : major * 100 + minor * 10
+        ;
+
+        const QByteArray profile = isGLES && version > 100 ? QByteArrayLiteral(" es")
+                                   : version >= 150 && format.api() == QShaderFormat::OpenGLCoreProfile ? QByteArrayLiteral(" core")
+                                   : version >= 150 && format.api() == QShaderFormat::OpenGLCompatibilityProfile ? QByteArrayLiteral(" compatibility")
+                                   : QByteArray();
+
+        code << (QByteArrayLiteral("#version ") + QByteArray::number(version) + profile);
+        code << QByteArray();
+    }
+
+    const auto intersectsEnabledLayers = [enabledLayers] (const QStringList &layers) {
+        return layers.isEmpty()
+            || std::any_of(layers.cbegin(), layers.cend(),
+                           [enabledLayers] (const QString &s) { return enabledLayers.contains(s); });
+    };
+
+    QVector<QString> globalInputVariables;
+    const QRegularExpression globalInputExtractRegExp(QStringLiteral("^.*\\s+(\\w+).*;$"));
+
+    const QVector<QShaderNode> nodes = graph.nodes();
+    for (const QShaderNode &node : nodes) {
+        if (intersectsEnabledLayers(node.layers())) {
+            const QByteArrayList headerSnippets = node.rule(format).headerSnippets;
+            for (const QByteArray &snippet : headerSnippets) {
+                code << replaceParameters(snippet, node, format);
+
+                // If node is an input, record the variable name into the globalInputVariables vector
+                if (node.type() == QShaderNode::Input) {
+                    const QRegularExpressionMatch match = globalInputExtractRegExp.match(QString::fromUtf8(code.last()));
+                    if (match.hasMatch())
+                        globalInputVariables.push_back(match.captured(1));
+                }
+            }
+        }
+    }
+
+    code << QByteArray();
+    code << QByteArrayLiteral("void main()");
+    code << QByteArrayLiteral("{");
+
+    const QRegularExpression temporaryVariableToAssignmentRegExp(QStringLiteral("([^;]*\\s+(v\\d+))\\s*=\\s*([^;]*);"));
+    const QRegularExpression temporaryVariableInAssignmentRegExp(QStringLiteral("\\W*(v\\d+)\\W*"));
+    const QRegularExpression statementRegExp(QStringLiteral("\\s*(\\w+)\\s*=\\s*([^;]*);"));
+
+    struct Variable;
+
+    struct Assignment
+    {
+        QString expression;
+        QVector<Variable *> referencedVariables;
+    };
+
+    struct Variable
+    {
+        enum Type {
+            GlobalInput,
+            TemporaryAssignment,
+            Output
+        };
+
+        QString name;
+        QString declaration;
+        int referenceCount = 0;
+        Assignment assignment;
+        Type type = TemporaryAssignment;
+        bool substituted = false;
+
+        static void substitute(Variable *v)
+        {
+            if (v->substituted)
+                return;
+
+            qCDebug(ShaderGenerator) << "Begin Substituting " << v->name << " = " << v->assignment.expression;
+            for (Variable *ref : qAsConst(v->assignment.referencedVariables)) {
+                // Recursively substitute
+                Variable::substitute(ref);
+
+                // Replace all variables referenced only once in the assignment
+                // by their actual expression
+                if (ref->referenceCount == 1 || ref->type == Variable::GlobalInput) {
+                    const QRegularExpression r(QStringLiteral("(.*\\b)(%1)(\\b.*)").arg(ref->name));
+                    if (v->assignment.referencedVariables.size() == 1)
+                        v->assignment.expression.replace(r,
+                                                         QStringLiteral("\\1%2\\3").arg(ref->assignment.expression));
+                    else
+                        v->assignment.expression.replace(r,
+                                                         QStringLiteral("(\\1%2\\3)").arg(ref->assignment.expression));
+                }
+            }
+            qCDebug(ShaderGenerator) << "Done Substituting " << v->name << " = " << v->assignment.expression;
+            v->substituted = true;
+        }
+    };
+
+    struct LineContent
+    {
+        QByteArray rawContent;
+        Variable *var = nullptr;
+    };
+
+    // Table to store temporary variables that should be replaced:
+    // - If variable references a a global variables
+    //   -> we will use the global variable directly
+    // - If variable references a function results
+    //   -> will be kept only if variable is referenced more than once.
+    // This avoids having vec3 v56 = vertexPosition; when we could
+    // just use vertexPosition directly.
+    // The added benefit is when having arrays, we don't try to create
+    // mat4 v38 = skinningPalelette[100] which would be invalid
+    QVector<Variable> temporaryVariables;
+    // Reserve more than enough space to ensure no reallocation will take place
+    temporaryVariables.reserve(nodes.size() * 8);
+
+    QVector<LineContent> lines;
+
+    auto createVariable = [&] () -> Variable * {
+        Q_ASSERT(temporaryVariables.capacity() > 0);
+        temporaryVariables.resize(temporaryVariables.size() + 1);
+        return &temporaryVariables.last();
+    };
+
+    auto findVariable = [&] (const QString &name) -> Variable * {
+        const auto end = temporaryVariables.end();
+        auto it = std::find_if(temporaryVariables.begin(), end,
+                               [=] (const Variable &a) { return a.name == name; });
+        if (it != end)
+            return &(*it);
+        return nullptr;
+    };
+
+    auto gatherTemporaryVariablesFromAssignment = [&] (Variable *v, const QString &assignmentContent) {
+        QRegularExpressionMatchIterator subMatchIt = temporaryVariableInAssignmentRegExp.globalMatch(assignmentContent);
+        while (subMatchIt.hasNext()) {
+            const QRegularExpressionMatch subMatch = subMatchIt.next();
+            const QString variableName = subMatch.captured(1);
+
+            // Variable we care about should already exists -> an expression cannot reference a variable that hasn't been defined
+            Variable *u = findVariable(variableName);
+            Q_ASSERT(u);
+
+            // Increase reference count for u
+            ++u->referenceCount;
+            // Insert u as reference for variable v
+            v->assignment.referencedVariables.push_back(u);
+        }
+    };
+
+    for (const QShaderGraph::Statement &statement : graph.createStatements(enabledLayers)) {
+        const QShaderNode node = statement.node;
+        QByteArray line = node.rule(format).substitution;
+        const QVector<QShaderNodePort> ports = node.ports();
+
+        struct VariableReplacement {
+            QByteArray placeholder;
+            QByteArray variable;
+        };
+
+        QVector<VariableReplacement> variableReplacements;
+
+        // Generate temporary variable names vN
+        for (const QShaderNodePort &port : ports) {
+            const QString portName = port.name;
+            const QShaderNodePort::Direction portDirection = port.direction;
+            const bool isInput = port.direction == QShaderNodePort::Input;
+
+            const int portIndex = statement.portIndex(portDirection, portName);
+
+            Q_ASSERT(portIndex >= 0);
+
+            const int variableIndex = isInput ? statement.inputs.at(portIndex)
+                                              : statement.outputs.at(portIndex);
+            if (variableIndex < 0)
+                continue;
+
+            VariableReplacement replacement;
+            replacement.placeholder = QByteArrayLiteral("$") + portName.toUtf8();
+            replacement.variable = QByteArrayLiteral("v") + QByteArray::number(variableIndex);
+
+            variableReplacements.append(std::move(replacement));
+        }
+
+        int begin = 0;
+        while ((begin = line.indexOf('$', begin)) != -1) {
+            int end = begin + 1;
+            char endChar = line.at(end);
+            const int size = line.size();
+            while (end < size && (std::isalnum(endChar) || endChar == '_')) {
+                ++end;
+                endChar = line.at(end);
+            }
+
+            const int placeholderLength = end - begin;
+
+            const QByteArray variableName = line.mid(begin, placeholderLength);
+            const auto replacementIt = std::find_if(variableReplacements.cbegin(), variableReplacements.cend(),
+                                              [&variableName](const VariableReplacement &replacement) {
+                return variableName == replacement.placeholder;
+            });
+
+            if (replacementIt != variableReplacements.cend()) {
+                line.replace(begin, placeholderLength, replacementIt->variable);
+                begin += replacementIt->variable.length();
+            } else {
+                begin = end;
+            }
+        }
+
+        // Substitute variable names by generated vN variable names
+        const QByteArray substitutionedLine = replaceParameters(line, node, format);
+
+        QRegularExpressionMatchIterator matches;
+
+        switch (node.type()) {
+        case QShaderNode::Input:
+        case QShaderNode::Output:
+            matches = statementRegExp.globalMatch(QString::fromUtf8(substitutionedLine));
+            break;
+        case QShaderNode::Function:
+            matches = temporaryVariableToAssignmentRegExp.globalMatch(QString::fromUtf8(substitutionedLine));
+            break;
+        case QShaderNode::Invalid:
+            break;
+        }
+
+        while (matches.hasNext()) {
+            QRegularExpressionMatch match = matches.next();
+
+            Variable *v = nullptr;
+
+            switch (node.type()) {
+            // Record name of temporary variable that possibly references a global input
+            // We will replace the temporary variables by the matching global variables later
+            case QShaderNode::Input: {
+                const QString localVariable = match.captured(1);
+                const QString globalVariable = match.captured(2);
+
+                v = createVariable();
+                v->name = localVariable;
+                v->type = Variable::GlobalInput;
+
+                Assignment assignment;
+                assignment.expression = globalVariable;
+                v->assignment = assignment;
+                break;
+            }
+
+            case QShaderNode::Function: {
+                const QString localVariableDeclaration = match.captured(1);
+                const QString localVariableName = match.captured(2);
+                const QString assignmentContent = match.captured(3);
+
+                // Add new variable -> it cannot exist already
+                v = createVariable();
+                v->name = localVariableName;
+                v->declaration = localVariableDeclaration;
+                v->assignment.expression = assignmentContent;
+
+                // Find variables that may be referenced in the assignment
+                gatherTemporaryVariablesFromAssignment(v, assignmentContent);
+                break;
+            }
+
+            case QShaderNode::Output: {
+                const QString outputDeclaration = match.captured(1);
+                const QString assignmentContent = match.captured(2);
+
+                v = createVariable();
+                v->name = outputDeclaration;
+                v->declaration = outputDeclaration;
+                v->type = Variable::Output;
+
+                Assignment assignment;
+                assignment.expression = assignmentContent;
+                v->assignment = assignment;
+
+                // Find variables that may be referenced in the assignment
+                gatherTemporaryVariablesFromAssignment(v, assignmentContent);
+                break;
+            }
+            case QShaderNode::Invalid:
+                break;
+            }
+
+            LineContent lineContent;
+            lineContent.rawContent = QByteArray(QByteArrayLiteral("    ") + substitutionedLine);
+            lineContent.var = v;
+            lines << lineContent;
+        }
+    }
+
+    // Go through all lines
+    // Perform substitution of line with temporary variables substitution
+    for (LineContent &lineContent : lines) {
+        Variable *v = lineContent.var;
+        qCDebug(ShaderGenerator) << lineContent.rawContent;
+        if (v != nullptr) {
+            Variable::substitute(v);
+
+            qCDebug(ShaderGenerator) << "Line " << lineContent.rawContent << "is assigned to temporary" << v->name;
+
+            // Check number of occurrences a temporary variable is referenced
+            if (v->referenceCount == 1 || v->type == Variable::GlobalInput) {
+                // If it is referenced only once, no point in creating a temporary
+                // Clear content for current line
+                lineContent.rawContent.clear();
+                // We assume expression that were referencing vN will have vN properly substituted
+            } else {
+                lineContent.rawContent = QStringLiteral("    %1 = %2;").arg(v->declaration)
+                                                                       .arg(v->assignment.expression)
+                                                                       .toUtf8();
+            }
+
+            qCDebug(ShaderGenerator) << "Updated Line is " << lineContent.rawContent;
+        }
+    }
+
+    // Go throug all lines and insert content
+    for (const LineContent &lineContent : qAsConst(lines)) {
+        if (!lineContent.rawContent.isEmpty()) {
+            code << lineContent.rawContent;
+        }
+    }
+
+    code << QByteArrayLiteral("}");
+    code << QByteArray();
+
+    return code.join('\n');
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadergenerator_p.h b/src/render/shadergraph/qshadergenerator_p.h
new file mode 100644
index 000000000..aebeaa8f2
--- /dev/null
+++ b/src/render/shadergraph/qshadergenerator_p.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERGENERATOR_P_H
+#define QT3DRENDER_QSHADERGENERATOR_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <Qt3DRender/private/qshadergraph_p.h>
+#include <QtCore/QLoggingCategory>
+
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+Q_DECLARE_LOGGING_CATEGORY(ShaderGenerator)
+
+class QShaderGenerator
+{
+public:
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QByteArray createShaderCode(const QStringList &enabledLayers = QStringList()) const;
+
+    QShaderGraph graph;
+    QShaderFormat format;
+};
+
+}
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderGenerator, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGenerator)
+
+#endif // QT3DRENDER_QSHADERGENERATOR_P_H
diff --git a/src/render/shadergraph/qshadergraph.cpp b/src/render/shadergraph/qshadergraph.cpp
new file mode 100644
index 000000000..c2f3c343e
--- /dev/null
+++ b/src/render/shadergraph/qshadergraph.cpp
@@ -0,0 +1,317 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadergraph_p.h"
+
+QT_BEGIN_NAMESPACE
+namespace Qt3DRender
+{
+
+namespace
+{
+    QVector<QShaderNode> copyOutputNodes(const QVector<QShaderNode> &nodes, const QVector<QShaderGraph::Edge> &edges)
+    {
+        auto res = QVector<QShaderNode>();
+        std::copy_if(nodes.cbegin(), nodes.cend(),
+                     std::back_inserter(res),
+                     [&edges] (const QShaderNode &node) {
+                         return node.type() == QShaderNode::Output ||
+                                (node.type() == QShaderNode::Function &&
+                                 !std::any_of(edges.cbegin(),
+                                              edges.cend(),
+                                              [&node] (const QShaderGraph::Edge &edge) {
+                                                  return edge.sourceNodeUuid ==
+                                                         node.uuid();
+                                              }));
+                     });
+        return res;
+    }
+
+    QVector<QShaderGraph::Edge> incomingEdges(const QVector<QShaderGraph::Edge> &edges, const QUuid &uuid)
+    {
+        auto res = QVector<QShaderGraph::Edge>();
+        std::copy_if(edges.cbegin(), edges.cend(),
+                     std::back_inserter(res),
+                     [uuid] (const QShaderGraph::Edge &edge) {
+                         return edge.sourceNodeUuid == uuid;
+                     });
+        return res;
+    }
+
+    QVector<QShaderGraph::Edge> outgoingEdges(const QVector<QShaderGraph::Edge> &edges, const QUuid &uuid)
+    {
+        auto res = QVector<QShaderGraph::Edge>();
+        std::copy_if(edges.cbegin(), edges.cend(),
+                     std::back_inserter(res),
+                     [uuid] (const QShaderGraph::Edge &edge) {
+                         return edge.targetNodeUuid == uuid;
+                     });
+        return res;
+    }
+
+    QShaderGraph::Statement nodeToStatement(const QShaderNode &node, int &nextVarId)
+    {
+        auto statement = QShaderGraph::Statement();
+        statement.node = node;
+
+        const QVector<QShaderNodePort> ports = node.ports();
+        for (const QShaderNodePort &port : ports) {
+            if (port.direction == QShaderNodePort::Input) {
+                statement.inputs.append(-1);
+            } else {
+                statement.outputs.append(nextVarId);
+                nextVarId++;
+            }
+        }
+        return statement;
+    }
+
+    QShaderGraph::Statement completeStatement(const QHash<QUuid, QShaderGraph::Statement> &idHash,
+                                              const QVector<QShaderGraph::Edge> edges,
+                                              const QUuid &uuid)
+    {
+        auto targetStatement = idHash.value(uuid);
+        for (const QShaderGraph::Edge &edge : edges) {
+            if (edge.targetNodeUuid != uuid)
+                continue;
+
+            const QShaderGraph::Statement sourceStatement = idHash.value(edge.sourceNodeUuid);
+            const int sourcePortIndex = sourceStatement.portIndex(QShaderNodePort::Output, edge.sourcePortName);
+            const int targetPortIndex = targetStatement.portIndex(QShaderNodePort::Input, edge.targetPortName);
+
+            if (sourcePortIndex < 0 || targetPortIndex < 0)
+                continue;
+
+            const QVector<int> sourceOutputs = sourceStatement.outputs;
+            QVector<int> &targetInputs = targetStatement.inputs;
+            targetInputs[targetPortIndex] = sourceOutputs[sourcePortIndex];
+        }
+        return targetStatement;
+    }
+
+    void removeNodesWithUnboundInputs(QVector<QShaderGraph::Statement> &statements,
+                                      const QVector<QShaderGraph::Edge> &allEdges)
+    {
+        // A node is invalid if any of its input ports is disconected
+        // or connected to the output port of another invalid node.
+
+        // Keeps track of the edges from the nodes we know to be valid
+        // to unvisited nodes
+        auto currentEdges = QVector<QShaderGraph::Edge>();
+
+        statements.erase(std::remove_if(statements.begin(),
+                                        statements.end(),
+                                        [&currentEdges, &allEdges] (const QShaderGraph::Statement &statement) {
+            const QShaderNode &node = statement.node;
+            const QVector<QShaderGraph::Edge> outgoing = outgoingEdges(currentEdges, node.uuid());
+            const QVector<QShaderNodePort> ports = node.ports();
+
+            bool allInputsConnected = true;
+            for (const QShaderNodePort &port : node.ports()) {
+                if (port.direction == QShaderNodePort::Output)
+                    continue;
+
+                const auto edgeIt = std::find_if(outgoing.cbegin(),
+                                                 outgoing.cend(),
+                                                 [&port] (const QShaderGraph::Edge &edge) {
+                    return edge.targetPortName == port.name;
+                });
+
+                if (edgeIt != outgoing.cend())
+                    currentEdges.removeAll(*edgeIt);
+                else
+                    allInputsConnected = false;
+            }
+
+            if (allInputsConnected) {
+                const QVector<QShaderGraph::Edge> incoming = incomingEdges(allEdges, node.uuid());
+                currentEdges.append(incoming);
+            }
+
+            return !allInputsConnected;
+        }),
+                         statements.end());
+    }
+}
+
+QUuid QShaderGraph::Statement::uuid() const noexcept
+{
+    return node.uuid();
+}
+
+int QShaderGraph::Statement::portIndex(QShaderNodePort::Direction direction, const QString &portName) const noexcept
+{
+    const QVector<QShaderNodePort> ports = node.ports();
+    int index = 0;
+    for (const QShaderNodePort &port : ports) {
+        if (port.name == portName && port.direction == direction)
+            return index;
+        else if (port.direction == direction)
+            index++;
+    }
+    return -1;
+}
+
+void QShaderGraph::addNode(const QShaderNode &node)
+{
+    removeNode(node);
+    m_nodes.append(node);
+}
+
+void QShaderGraph::removeNode(const QShaderNode &node)
+{
+    const auto it = std::find_if(m_nodes.begin(), m_nodes.end(),
+                                 [node] (const QShaderNode &n) { return n.uuid() == node.uuid(); });
+    if (it != m_nodes.end())
+        m_nodes.erase(it);
+}
+
+QVector<QShaderNode> QShaderGraph::nodes() const noexcept
+{
+    return m_nodes;
+}
+
+void QShaderGraph::addEdge(const QShaderGraph::Edge &edge)
+{
+    if (m_edges.contains(edge))
+        return;
+    m_edges.append(edge);
+}
+
+void QShaderGraph::removeEdge(const QShaderGraph::Edge &edge)
+{
+    m_edges.removeAll(edge);
+}
+
+QVector<QShaderGraph::Edge> QShaderGraph::edges() const noexcept
+{
+    return m_edges;
+}
+
+QVector<QShaderGraph::Statement> QShaderGraph::createStatements(const QStringList &enabledLayers) const
+{
+    const auto intersectsEnabledLayers = [enabledLayers] (const QStringList &layers) {
+        return layers.isEmpty()
+            || std::any_of(layers.cbegin(), layers.cend(),
+                           [enabledLayers] (const QString &s) { return enabledLayers.contains(s); });
+    };
+
+    const QVector<QShaderNode> enabledNodes = [this, intersectsEnabledLayers] {
+        auto res = QVector<QShaderNode>();
+        std::copy_if(m_nodes.cbegin(), m_nodes.cend(),
+                     std::back_inserter(res),
+                     [intersectsEnabledLayers] (const QShaderNode &node) {
+                         return intersectsEnabledLayers(node.layers());
+                     });
+        return res;
+    }();
+
+    const QVector<Edge> enabledEdges = [this, intersectsEnabledLayers] {
+        auto res = QVector<Edge>();
+        std::copy_if(m_edges.cbegin(), m_edges.cend(),
+                     std::back_inserter(res),
+                     [intersectsEnabledLayers] (const Edge &edge) {
+                         return intersectsEnabledLayers(edge.layers);
+                     });
+        return res;
+    }();
+
+    const QHash<QUuid, Statement> idHash = [enabledNodes] {
+        auto nextVarId = 0;
+        auto res = QHash<QUuid, Statement>();
+        for (const QShaderNode &node : enabledNodes)
+            res.insert(node.uuid(), nodeToStatement(node, nextVarId));
+        return res;
+    }();
+
+    auto result = QVector<Statement>();
+    QVector<Edge> currentEdges = enabledEdges;
+    QVector<QUuid> currentUuids = [enabledNodes, enabledEdges] {
+        const QVector<QShaderNode> inputs = copyOutputNodes(enabledNodes, enabledEdges);
+        auto res = QVector<QUuid>();
+        std::transform(inputs.cbegin(), inputs.cend(),
+                       std::back_inserter(res),
+                       [](const QShaderNode &node) { return node.uuid(); });
+        return res;
+    }();
+
+    // Implements Kahn's algorithm to flatten the graph
+    // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm
+    //
+    // We implement it with a small twist though, we follow the edges backward
+    // because we want to track the dependencies from the output nodes and not the
+    // input nodes
+    while (!currentUuids.isEmpty()) {
+        const QUuid uuid = currentUuids.takeFirst();
+        result.append(completeStatement(idHash, enabledEdges, uuid));
+
+        const QVector<QShaderGraph::Edge> outgoing = outgoingEdges(currentEdges, uuid);
+        for (const QShaderGraph::Edge &outgoingEdge : outgoing) {
+            currentEdges.removeAll(outgoingEdge);
+            const QUuid nextUuid = outgoingEdge.sourceNodeUuid;
+            const QVector<QShaderGraph::Edge> incoming = incomingEdges(currentEdges, nextUuid);
+            if (incoming.isEmpty()) {
+                currentUuids.append(nextUuid);
+            }
+        }
+    }
+
+    std::reverse(result.begin(), result.end());
+
+    removeNodesWithUnboundInputs(result, enabledEdges);
+
+    return result;
+}
+
+bool operator==(const QShaderGraph::Edge &lhs, const QShaderGraph::Edge &rhs) noexcept
+{
+    return lhs.sourceNodeUuid == rhs.sourceNodeUuid
+        && lhs.sourcePortName == rhs.sourcePortName
+        && lhs.targetNodeUuid == rhs.targetNodeUuid
+        && lhs.targetPortName == rhs.targetPortName;
+}
+
+bool operator==(const QShaderGraph::Statement &lhs, const QShaderGraph::Statement &rhs) noexcept
+{
+    return lhs.inputs == rhs.inputs
+        && lhs.outputs == rhs.outputs
+        && lhs.node.uuid() == rhs.node.uuid();
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadergraph_p.h b/src/render/shadergraph/qshadergraph_p.h
new file mode 100644
index 000000000..de746f7b2
--- /dev/null
+++ b/src/render/shadergraph/qshadergraph_p.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERGRAPH_P_H
+#define QT3DRENDER_QSHADERGRAPH_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <Qt3DRender/private/qshadernode_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+class QShaderGraph
+{
+public:
+    class Edge
+    {
+    public:
+        QStringList layers;
+        QUuid sourceNodeUuid;
+        QString sourcePortName;
+        QUuid targetNodeUuid;
+        QString targetPortName;
+    };
+
+    class Statement
+    {
+    public:
+        Q_3DRENDERSHARED_PRIVATE_EXPORT QUuid uuid() const noexcept;
+        Q_3DRENDERSHARED_PRIVATE_EXPORT int portIndex(QShaderNodePort::Direction direction, const QString &portName) const noexcept;
+
+        QShaderNode node;
+        QVector<int> inputs;
+        QVector<int> outputs;
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void addNode(const QShaderNode &node);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void removeNode(const QShaderNode &node);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVector<QShaderNode> nodes() const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void addEdge(const Edge &edge);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void removeEdge(const Edge &edge);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVector<Edge> edges() const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVector<Statement> createStatements(const QStringList &enabledLayers = QStringList()) const;
+
+private:
+    QVector<QShaderNode> m_nodes;
+    QVector<Edge> m_edges;
+};
+
+Q_3DRENDERSHARED_PRIVATE_EXPORT bool operator==(const QShaderGraph::Edge &lhs, const QShaderGraph::Edge &rhs) noexcept;
+
+inline bool operator!=(const QShaderGraph::Edge &lhs, const QShaderGraph::Edge &rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+Q_3DRENDERSHARED_PRIVATE_EXPORT bool operator==(const QShaderGraph::Statement &lhs, const QShaderGraph::Statement &rhs) noexcept;
+
+inline bool operator!=(const QShaderGraph::Statement &lhs, const QShaderGraph::Statement &rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+}
+
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderGraph, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderGraph::Edge, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderGraph::Statement, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGraph)
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGraph::Edge)
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGraph::Statement)
+
+#endif // QT3DRENDER_QSHADERGRAPH_P_H
diff --git a/src/render/shadergraph/qshadergraphloader.cpp b/src/render/shadergraph/qshadergraphloader.cpp
new file mode 100644
index 000000000..64f159e7b
--- /dev/null
+++ b/src/render/shadergraph/qshadergraphloader.cpp
@@ -0,0 +1,271 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadergraphloader_p.h"
+
+#include "qshadernodesloader_p.h"
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qjsonarray.h>
+#include <QtCore/qjsondocument.h>
+#include <QtCore/qjsonobject.h>
+#include <QtCore/qmetaobject.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+void qt_register_ShaderLanguage_enums();
+
+QShaderGraphLoader::QShaderGraphLoader() noexcept
+    : m_status(Null),
+      m_device(nullptr)
+{
+    qt_register_ShaderLanguage_enums();
+}
+
+QShaderGraphLoader::Status QShaderGraphLoader::status() const noexcept
+{
+    return m_status;
+}
+
+QShaderGraph QShaderGraphLoader::graph() const noexcept
+{
+    return m_graph;
+}
+
+QIODevice *QShaderGraphLoader::device() const noexcept
+{
+    return m_device;
+}
+
+void QShaderGraphLoader::setDevice(QIODevice *device) noexcept
+{
+    m_device = device;
+    m_graph = QShaderGraph();
+    m_status = !m_device ? Null
+             : (m_device->openMode() & QIODevice::ReadOnly) ? Waiting
+             : Error;
+}
+
+QHash<QString, QShaderNode> QShaderGraphLoader::prototypes() const noexcept
+{
+    return m_prototypes;
+}
+
+void QShaderGraphLoader::setPrototypes(const QHash<QString, QShaderNode> &prototypes) noexcept
+{
+    m_prototypes = prototypes;
+}
+
+void QShaderGraphLoader::load()
+{
+    if (m_status == Error)
+        return;
+
+    auto error = QJsonParseError();
+    const QJsonDocument document = QJsonDocument::fromJson(m_device->readAll(), &error);
+
+    if (error.error != QJsonParseError::NoError) {
+        qWarning() << "Invalid JSON document:" << error.errorString();
+        m_status = Error;
+        return;
+    }
+
+    if (document.isEmpty() || !document.isObject()) {
+        qWarning() << "Invalid JSON document, root should be an object";
+        m_status = Error;
+        return;
+    }
+
+    const QJsonObject root = document.object();
+
+    const QJsonValue nodesValue = root.value(QStringLiteral("nodes"));
+    if (!nodesValue.isArray()) {
+        qWarning() << "Invalid nodes property, should be an array";
+        m_status = Error;
+        return;
+    }
+
+    const QJsonValue edgesValue = root.value(QStringLiteral("edges"));
+    if (!edgesValue.isArray()) {
+        qWarning() << "Invalid edges property, should be an array";
+        m_status = Error;
+        return;
+    }
+
+    bool hasError = false;
+
+    const QJsonValue prototypesValue = root.value(QStringLiteral("prototypes"));
+    if (!prototypesValue.isUndefined()) {
+        if (prototypesValue.isObject()) {
+            QShaderNodesLoader loader;
+            loader.load(prototypesValue.toObject());
+            m_prototypes.insert(loader.nodes());
+        } else {
+            qWarning() << "Invalid prototypes property, should be an object";
+            m_status = Error;
+            return;
+        }
+    }
+
+    const QJsonArray nodes = nodesValue.toArray();
+    for (const QJsonValue &nodeValue : nodes) {
+        if (!nodeValue.isObject()) {
+            qWarning() << "Invalid node found";
+            hasError = true;
+            continue;
+        }
+
+        const QJsonObject nodeObject = nodeValue.toObject();
+
+        const QString uuidString = nodeObject.value(QStringLiteral("uuid")).toString();
+        const QUuid uuid = QUuid(uuidString);
+        if (uuid.isNull()) {
+            qWarning() << "Invalid UUID found in node:" << uuidString;
+            hasError = true;
+            continue;
+        }
+
+        const QString type = nodeObject.value(QStringLiteral("type")).toString();
+        if (!m_prototypes.contains(type)) {
+            qWarning() << "Unsupported node type found:" << type;
+            hasError = true;
+            continue;
+        }
+
+        const QJsonArray layersArray = nodeObject.value(QStringLiteral("layers")).toArray();
+        auto layers = QStringList();
+        for (const QJsonValue &layerValue : layersArray) {
+            layers.append(layerValue.toString());
+        }
+
+        QShaderNode node = m_prototypes.value(type);
+        node.setUuid(uuid);
+        node.setLayers(layers);
+
+        const QJsonValue parametersValue = nodeObject.value(QStringLiteral("parameters"));
+        if (parametersValue.isObject()) {
+            const QJsonObject parametersObject = parametersValue.toObject();
+            for (const QString &parameterName : parametersObject.keys()) {
+                const QJsonValue parameterValue = parametersObject.value(parameterName);
+                if (parameterValue.isObject()) {
+                    const QJsonObject parameterObject = parameterValue.toObject();
+                    const QString type = parameterObject.value(QStringLiteral("type")).toString();
+                    const int typeId = QMetaType::type(type.toUtf8());
+
+                    const QString value = parameterObject.value(QStringLiteral("value")).toString();
+                    auto variant = QVariant(value);
+
+                    if (QMetaType::typeFlags(typeId) & QMetaType::IsEnumeration) {
+                        const QMetaObject *metaObject = QMetaType::metaObjectForType(typeId);
+                        const char *className = metaObject->className();
+                        const QByteArray enumName = type.mid(static_cast<int>(qstrlen(className)) + 2).toUtf8();
+                        const QMetaEnum metaEnum = metaObject->enumerator(metaObject->indexOfEnumerator(enumName));
+                        const int enumValue = metaEnum.keyToValue(value.toUtf8());
+                        variant = QVariant(enumValue);
+                        variant.convert(typeId);
+                    } else {
+                        variant.convert(typeId);
+                    }
+                    node.setParameter(parameterName, variant);
+                } else {
+                    node.setParameter(parameterName, parameterValue.toVariant());
+                }
+            }
+        }
+
+        m_graph.addNode(node);
+    }
+
+    const QJsonArray edges = edgesValue.toArray();
+    for (const QJsonValue &edgeValue : edges) {
+        if (!edgeValue.isObject()) {
+            qWarning() << "Invalid edge found";
+            hasError = true;
+            continue;
+        }
+
+        const QJsonObject edgeObject = edgeValue.toObject();
+
+        const QString sourceUuidString = edgeObject.value(QStringLiteral("sourceUuid")).toString();
+        const QUuid sourceUuid = QUuid(sourceUuidString);
+        if (sourceUuid.isNull()) {
+            qWarning() << "Invalid source UUID found in edge:" << sourceUuidString;
+            hasError = true;
+            continue;
+        }
+
+        const QString sourcePort = edgeObject.value(QStringLiteral("sourcePort")).toString();
+
+        const QString targetUuidString = edgeObject.value(QStringLiteral("targetUuid")).toString();
+        const QUuid targetUuid = QUuid(targetUuidString);
+        if (targetUuid.isNull()) {
+            qWarning() << "Invalid target UUID found in edge:" << targetUuidString;
+            hasError = true;
+            continue;
+        }
+
+        const QString targetPort = edgeObject.value(QStringLiteral("targetPort")).toString();
+
+        const QJsonArray layersArray = edgeObject.value(QStringLiteral("layers")).toArray();
+        auto layers = QStringList();
+        for (const QJsonValue &layerValue : layersArray) {
+            layers.append(layerValue.toString());
+        }
+
+        auto edge = QShaderGraph::Edge();
+        edge.sourceNodeUuid = sourceUuid;
+        edge.sourcePortName = sourcePort;
+        edge.targetNodeUuid = targetUuid;
+        edge.targetPortName = targetPort;
+        edge.layers = layers;
+        m_graph.addEdge(edge);
+    }
+
+    if (hasError) {
+        m_status = Error;
+        m_graph = QShaderGraph();
+    } else {
+        m_status = Ready;
+    }
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadergraphloader_p.h b/src/render/shadergraph/qshadergraphloader_p.h
new file mode 100644
index 000000000..20589d724
--- /dev/null
+++ b/src/render/shadergraph/qshadergraphloader_p.h
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERGRAPHLOADER_P_H
+#define QT3DRENDER_QSHADERGRAPHLOADER_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <Qt3DRender/private/qshadergraph_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+namespace Qt3DRender
+{
+
+class QShaderGraphLoader
+{
+public:
+    enum Status : char {
+        Null,
+        Waiting,
+        Ready,
+        Error
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QShaderGraphLoader() noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT Status status() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QShaderGraph graph() const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QIODevice *device() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setDevice(QIODevice *device) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QHash<QString, QShaderNode> prototypes() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setPrototypes(const QHash<QString, QShaderNode> &prototypes) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void load();
+
+private:
+    Status m_status;
+    QIODevice *m_device;
+    QHash<QString, QShaderNode> m_prototypes;
+    QShaderGraph m_graph;
+};
+
+
+}
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderGraphLoader, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGraphLoader)
+Q_DECLARE_METATYPE(Qt3DRender::QShaderGraphLoader::Status)
+
+#endif // QT3DRENDER_QSHADERGRAPHLOADER_P_H
diff --git a/src/render/shadergraph/qshaderlanguage.cpp b/src/render/shadergraph/qshaderlanguage.cpp
new file mode 100644
index 000000000..1630e3de8
--- /dev/null
+++ b/src/render/shadergraph/qshaderlanguage.cpp
@@ -0,0 +1,57 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshaderlanguage_p.h"
+
+#include <QtCore/qcoreapplication.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+// Note: to be invoked explicitly. Relying for example on
+// Q_COREAPP_STARTUP_FUNCTION would not be acceptable in static builds.
+void qt_register_ShaderLanguage_enums()
+{
+    qRegisterMetaType<QShaderLanguage::StorageQualifier>();
+    qRegisterMetaType<QShaderLanguage::VariableType>();
+}
+}
+
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshaderlanguage_p.h b/src/render/shadergraph/qshaderlanguage_p.h
new file mode 100644
index 000000000..1a56d7476
--- /dev/null
+++ b/src/render/shadergraph/qshaderlanguage_p.h
@@ -0,0 +1,164 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERLANGUAGE_P_H
+#define QT3DRENDER_QSHADERLANGUAGE_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <QtCore/qmetatype.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QShaderLanguage
+{
+    Q_NAMESPACE_EXPORT(Q_3DRENDERSHARED_PRIVATE_EXPORT)
+
+    enum StorageQualifier : char {
+        Const = 1,
+        Input,
+        BuiltIn,
+        Output,
+        Uniform
+    };
+    Q_ENUM_NS(StorageQualifier)
+
+    enum VariableType : int {
+        Bool = 1,
+        Int,
+        Uint,
+        Float,
+        Double,
+        Vec2,
+        Vec3,
+        Vec4,
+        DVec2,
+        DVec3,
+        DVec4,
+        BVec2,
+        BVec3,
+        BVec4,
+        IVec2,
+        IVec3,
+        IVec4,
+        UVec2,
+        UVec3,
+        UVec4,
+        Mat2,
+        Mat3,
+        Mat4,
+        Mat2x2,
+        Mat2x3,
+        Mat2x4,
+        Mat3x2,
+        Mat3x3,
+        Mat3x4,
+        Mat4x2,
+        Mat4x3,
+        Mat4x4,
+        DMat2,
+        DMat3,
+        DMat4,
+        DMat2x2,
+        DMat2x3,
+        DMat2x4,
+        DMat3x2,
+        DMat3x3,
+        DMat3x4,
+        DMat4x2,
+        DMat4x3,
+        DMat4x4,
+        Sampler1D,
+        Sampler2D,
+        Sampler3D,
+        SamplerCube,
+        Sampler2DRect,
+        Sampler2DMs,
+        SamplerBuffer,
+        Sampler1DArray,
+        Sampler2DArray,
+        Sampler2DMsArray,
+        SamplerCubeArray,
+        Sampler1DShadow,
+        Sampler2DShadow,
+        Sampler2DRectShadow,
+        Sampler1DArrayShadow,
+        Sampler2DArrayShadow,
+        SamplerCubeShadow,
+        SamplerCubeArrayShadow,
+        ISampler1D,
+        ISampler2D,
+        ISampler3D,
+        ISamplerCube,
+        ISampler2DRect,
+        ISampler2DMs,
+        ISamplerBuffer,
+        ISampler1DArray,
+        ISampler2DArray,
+        ISampler2DMsArray,
+        ISamplerCubeArray,
+        USampler1D,
+        USampler2D,
+        USampler3D,
+        USamplerCube,
+        USampler2DRect,
+        USampler2DMs,
+        USamplerBuffer,
+        USampler1DArray,
+        USampler2DArray,
+        USampler2DMsArray,
+        USamplerCubeArray
+    };
+    Q_ENUM_NS(VariableType)
+}
+
+QT_END_NAMESPACE
+
+#endif // QT3DRENDER_QSHADERLANGUAGE_P_H
diff --git a/src/render/shadergraph/qshadernode.cpp b/src/render/shadergraph/qshadernode.cpp
new file mode 100644
index 000000000..e0421e006
--- /dev/null
+++ b/src/render/shadergraph/qshadernode.cpp
@@ -0,0 +1,174 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadernode_p.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+QShaderNode::Type QShaderNode::type() const noexcept
+{
+    int inputCount = 0;
+    int outputCount = 0;
+    for (const auto &port : qAsConst(m_ports)) {
+        switch (port.direction) {
+        case QShaderNodePort::Input:
+            inputCount++;
+            break;
+        case QShaderNodePort::Output:
+            outputCount++;
+            break;
+        }
+    }
+
+    return (inputCount == 0 && outputCount == 0) ? Invalid
+         : (inputCount > 0 && outputCount == 0) ? Output
+         : (inputCount == 0 && outputCount > 0) ? Input
+         : Function;
+}
+
+QUuid QShaderNode::uuid() const noexcept
+{
+    return m_uuid;
+}
+
+void QShaderNode::setUuid(const QUuid &uuid) noexcept
+{
+    m_uuid = uuid;
+}
+
+QStringList QShaderNode::layers() const noexcept
+{
+    return m_layers;
+}
+
+void QShaderNode::setLayers(const QStringList &layers) noexcept
+{
+    m_layers = layers;
+}
+
+QVector<QShaderNodePort> QShaderNode::ports() const noexcept
+{
+    return m_ports;
+}
+
+void QShaderNode::addPort(const QShaderNodePort &port)
+{
+    removePort(port);
+    m_ports.append(port);
+}
+
+void QShaderNode::removePort(const QShaderNodePort &port)
+{
+    const auto it = std::find_if(m_ports.begin(), m_ports.end(),
+                                 [port](const QShaderNodePort &p) {
+                                    return p.name == port.name;
+                                 });
+    if (it != m_ports.end())
+        m_ports.erase(it);
+}
+
+QStringList QShaderNode::parameterNames() const
+{
+    return m_parameters.keys();
+}
+
+QVariant QShaderNode::parameter(const QString &name) const
+{
+    return m_parameters.value(name);
+}
+
+void QShaderNode::setParameter(const QString &name, const QVariant &value)
+{
+    m_parameters.insert(name, value);
+}
+
+void QShaderNode::clearParameter(const QString &name)
+{
+    m_parameters.remove(name);
+}
+
+void QShaderNode::addRule(const QShaderFormat &format, const QShaderNode::Rule &rule)
+{
+    removeRule(format);
+    m_rules << qMakePair(format, rule);
+}
+
+void QShaderNode::removeRule(const QShaderFormat &format)
+{
+    const auto it = std::find_if(m_rules.begin(), m_rules.end(),
+                                 [format](const QPair<QShaderFormat, Rule> &entry) {
+                                     return entry.first == format;
+                                 });
+    if (it != m_rules.end())
+        m_rules.erase(it);
+}
+
+QVector<QShaderFormat> QShaderNode::availableFormats() const
+{
+    auto res = QVector<QShaderFormat>();
+    std::transform(m_rules.cbegin(), m_rules.cend(),
+                   std::back_inserter(res),
+                   [](const QPair<QShaderFormat, Rule> &entry) { return entry.first; });
+    return res;
+}
+
+QShaderNode::Rule QShaderNode::rule(const QShaderFormat &format) const
+{
+    const auto it = std::find_if(m_rules.crbegin(), m_rules.crend(),
+                                 [format](const QPair<QShaderFormat, Rule> &entry) {
+        return format.supports(entry.first);
+    });
+    return it != m_rules.crend() ? it->second : Rule();
+}
+
+QShaderNode::Rule::Rule(const QByteArray &subs, const QByteArrayList &snippets) noexcept
+    : substitution(subs),
+      headerSnippets(snippets)
+{
+}
+
+bool operator==(const QShaderNode::Rule &lhs, const QShaderNode::Rule &rhs) noexcept
+{
+    return lhs.substitution == rhs.substitution
+        && lhs.headerSnippets == rhs.headerSnippets;
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadernode_p.h b/src/render/shadergraph/qshadernode_p.h
new file mode 100644
index 000000000..92e0e8e14
--- /dev/null
+++ b/src/render/shadergraph/qshadernode_p.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERNODE_P_H
+#define QT3DRENDER_QSHADERNODE_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <Qt3DRender/private/qshaderformat_p.h>
+#include <Qt3DRender/private/qshadernodeport_p.h>
+
+#include <QtCore/quuid.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+class QShaderNode
+{
+public:
+    enum Type : char {
+        Invalid,
+        Input,
+        Output,
+        Function
+    };
+
+    class Rule
+    {
+    public:
+        Q_3DRENDERSHARED_PRIVATE_EXPORT Rule(const QByteArray &substitution = QByteArray(), const QByteArrayList &headerSnippets = QByteArrayList()) noexcept;
+
+        QByteArray substitution;
+        QByteArrayList headerSnippets;
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT Type type() const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QUuid uuid() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setUuid(const QUuid &uuid) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QStringList layers() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setLayers(const QStringList &layers) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVector<QShaderNodePort> ports() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void addPort(const QShaderNodePort &port);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void removePort(const QShaderNodePort &port);
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QStringList parameterNames() const;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVariant parameter(const QString &name) const;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setParameter(const QString &name, const QVariant &value);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void clearParameter(const QString &name);
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void addRule(const QShaderFormat &format, const Rule &rule);
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void removeRule(const QShaderFormat &format);
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QVector<QShaderFormat> availableFormats() const;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT Rule rule(const QShaderFormat &format) const;
+
+private:
+    QUuid m_uuid;
+    QStringList m_layers;
+    QVector<QShaderNodePort> m_ports;
+    QHash<QString, QVariant> m_parameters;
+    QVector<QPair<QShaderFormat, QShaderNode::Rule>> m_rules;
+};
+
+Q_3DRENDERSHARED_PRIVATE_EXPORT bool operator==(const QShaderNode::Rule &lhs, const QShaderNode::Rule &rhs) noexcept;
+
+inline bool operator!=(const QShaderNode::Rule &lhs, const QShaderNode::Rule &rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+}
+
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderNode, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderNode::Rule, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderNode)
+Q_DECLARE_METATYPE(Qt3DRender::QShaderNode::Rule)
+
+#endif // QT3DRENDER_QSHADERNODE_P_H
diff --git a/src/render/shadergraph/qshadernodeport.cpp b/src/render/shadergraph/qshadernodeport.cpp
new file mode 100644
index 000000000..a79c32234
--- /dev/null
+++ b/src/render/shadergraph/qshadernodeport.cpp
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadernodeport_p.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+QShaderNodePort::QShaderNodePort() noexcept
+    : direction(Output)
+{
+}
+
+bool operator==(const QShaderNodePort &lhs, const QShaderNodePort &rhs) noexcept
+{
+    return lhs.direction == rhs.direction
+        && lhs.name == rhs.name;
+}
+}
+
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadernodeport_p.h b/src/render/shadergraph/qshadernodeport_p.h
new file mode 100644
index 000000000..d83cdb8c4
--- /dev/null
+++ b/src/render/shadergraph/qshadernodeport_p.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERNODEPORT_P_H
+#define QT3DRENDER_QSHADERNODEPORT_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <QtCore/qstring.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+class QShaderNodePort
+{
+public:
+    enum Direction : char {
+        Input,
+        Output
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QShaderNodePort() noexcept;
+
+    QShaderNodePort::Direction direction;
+    QString name;
+};
+
+Q_3DRENDERSHARED_PRIVATE_EXPORT bool operator==(const QShaderNodePort &lhs, const QShaderNodePort &rhs) noexcept;
+
+inline bool operator!=(const QShaderNodePort &lhs, const QShaderNodePort &rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+
+}
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderNodePort, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderNodePort)
+
+#endif // QT3DRENDER_QSHADERNODEPORT_P_H
diff --git a/src/render/shadergraph/qshadernodesloader.cpp b/src/render/shadergraph/qshadernodesloader.cpp
new file mode 100644
index 000000000..8346ed3d5
--- /dev/null
+++ b/src/render/shadergraph/qshadernodesloader.cpp
@@ -0,0 +1,292 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qshadernodesloader_p.h"
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qjsonarray.h>
+#include <QtCore/qjsondocument.h>
+#include <QtCore/qjsonobject.h>
+#include <QtCore/qmetaobject.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender
+{
+QShaderNodesLoader::QShaderNodesLoader() noexcept
+    : m_status(Null),
+      m_device(nullptr)
+{
+}
+
+QShaderNodesLoader::Status QShaderNodesLoader::status() const noexcept
+{
+    return m_status;
+}
+
+QHash<QString, QShaderNode> QShaderNodesLoader::nodes() const noexcept
+{
+    return m_nodes;
+}
+
+QIODevice *QShaderNodesLoader::device() const noexcept
+{
+    return m_device;
+}
+
+void QShaderNodesLoader::setDevice(QIODevice *device) noexcept
+{
+    m_device = device;
+    m_nodes.clear();
+    m_status = !m_device ? Null
+             : (m_device->openMode() & QIODevice::ReadOnly) ? Waiting
+             : Error;
+}
+
+void QShaderNodesLoader::load()
+{
+    if (m_status == Error)
+        return;
+
+    auto error = QJsonParseError();
+    const QJsonDocument document = QJsonDocument::fromJson(m_device->readAll(), &error);
+
+    if (error.error != QJsonParseError::NoError) {
+        qWarning() << "Invalid JSON document:" << error.errorString();
+        m_status = Error;
+        return;
+    }
+
+    if (document.isEmpty() || !document.isObject()) {
+        qWarning() << "Invalid JSON document, root should be an object";
+        m_status = Error;
+        return;
+    }
+
+    const QJsonObject root = document.object();
+    load(root);
+}
+
+void QShaderNodesLoader::load(const QJsonObject &prototypesObject)
+{
+    bool hasError = false;
+
+    for (const QString &property : prototypesObject.keys()) {
+        const QJsonValue nodeValue = prototypesObject.value(property);
+        if (!nodeValue.isObject()) {
+            qWarning() << "Invalid node found";
+            hasError = true;
+            break;
+        }
+
+        const QJsonObject nodeObject = nodeValue.toObject();
+
+        auto node = QShaderNode();
+
+        const QJsonValue inputsValue = nodeObject.value(QStringLiteral("inputs"));
+        if (inputsValue.isArray()) {
+            const QJsonArray inputsArray = inputsValue.toArray();
+            for (const QJsonValue &inputValue : inputsArray) {
+                if (!inputValue.isString()) {
+                    qWarning() << "Non-string value in inputs";
+                    hasError = true;
+                    break;
+                }
+
+                auto input = QShaderNodePort();
+                input.direction = QShaderNodePort::Input;
+                input.name = inputValue.toString();
+                node.addPort(input);
+            }
+        }
+
+        const QJsonValue outputsValue = nodeObject.value(QStringLiteral("outputs"));
+        if (outputsValue.isArray()) {
+            const QJsonArray outputsArray = outputsValue.toArray();
+            for (const QJsonValue &outputValue : outputsArray) {
+                if (!outputValue.isString()) {
+                    qWarning() << "Non-string value in outputs";
+                    hasError = true;
+                    break;
+                }
+
+                auto output = QShaderNodePort();
+                output.direction = QShaderNodePort::Output;
+                output.name = outputValue.toString();
+                node.addPort(output);
+            }
+        }
+
+        const QJsonValue parametersValue = nodeObject.value(QStringLiteral("parameters"));
+        if (parametersValue.isObject()) {
+            const QJsonObject parametersObject = parametersValue.toObject();
+            for (const QString &parameterName : parametersObject.keys()) {
+                const QJsonValue parameterValue = parametersObject.value(parameterName);
+                if (parameterValue.isObject()) {
+                    const QJsonObject parameterObject = parameterValue.toObject();
+                    const QString type = parameterObject.value(QStringLiteral("type")).toString();
+                    const int typeId = QMetaType::type(type.toUtf8());
+
+                    const QString value = parameterObject.value(QStringLiteral("value")).toString();
+                    auto variant = QVariant(value);
+
+                    if (QMetaType::typeFlags(typeId) & QMetaType::IsEnumeration) {
+                        const QMetaObject *metaObject = QMetaType::metaObjectForType(typeId);
+                        const char *className = metaObject->className();
+                        const QByteArray enumName = type.mid(static_cast<int>(qstrlen(className)) + 2).toUtf8();
+                        const QMetaEnum metaEnum = metaObject->enumerator(metaObject->indexOfEnumerator(enumName));
+                        const int enumValue = metaEnum.keyToValue(value.toUtf8());
+                        variant = QVariant(enumValue);
+                        variant.convert(typeId);
+                    } else {
+                        variant.convert(typeId);
+                    }
+                    node.setParameter(parameterName, variant);
+                } else {
+                    node.setParameter(parameterName, parameterValue.toVariant());
+                }
+            }
+        }
+
+        const QJsonValue rulesValue = nodeObject.value(QStringLiteral("rules"));
+        if (rulesValue.isArray()) {
+            const QJsonArray rulesArray = rulesValue.toArray();
+            for (const QJsonValue &ruleValue : rulesArray) {
+                if (!ruleValue.isObject()) {
+                    qWarning() << "Rules should be objects";
+                    hasError = true;
+                    break;
+                }
+
+                const QJsonObject ruleObject = ruleValue.toObject();
+
+                const QJsonValue formatValue = ruleObject.value(QStringLiteral("format"));
+                if (!formatValue.isObject()) {
+                    qWarning() << "Format is mandatory in rules and should be an object";
+                    hasError = true;
+                    break;
+                }
+
+                const QJsonObject formatObject = formatValue.toObject();
+                auto format = QShaderFormat();
+
+                const QJsonValue apiValue = formatObject.value(QStringLiteral("api"));
+                if (!apiValue.isString()) {
+                    qWarning() << "Format API must be a string";
+                    hasError = true;
+                    break;
+                }
+
+                const QString api = apiValue.toString();
+                format.setApi(api == QStringLiteral("OpenGLES") ? QShaderFormat::OpenGLES
+                            : api == QStringLiteral("OpenGLNoProfile") ? QShaderFormat::OpenGLNoProfile
+                            : api == QStringLiteral("OpenGLCoreProfile") ? QShaderFormat::OpenGLCoreProfile
+                            : api == QStringLiteral("OpenGLCompatibilityProfile") ? QShaderFormat::OpenGLCompatibilityProfile
+                            : api == QStringLiteral("VulkanFlavoredGLSL") ? QShaderFormat::VulkanFlavoredGLSL
+                            : QShaderFormat::NoApi);
+                if (format.api() == QShaderFormat::NoApi) {
+                    qWarning() << "Format API must be one of: OpenGLES, OpenGLNoProfile, OpenGLCoreProfile or OpenGLCompatibilityProfile, VulkanFlavoredGLSL";
+                    hasError = true;
+                    break;
+                }
+
+                const QJsonValue majorValue = formatObject.value(QStringLiteral("major"));
+                const QJsonValue minorValue = formatObject.value(QStringLiteral("minor"));
+                if (!majorValue.isDouble() || !minorValue.isDouble()) {
+                    qWarning() << "Format major and minor version must be values";
+                    hasError = true;
+                    break;
+                }
+                format.setVersion(QVersionNumber(majorValue.toInt(), minorValue.toInt()));
+
+                const QJsonValue extensionsValue = formatObject.value(QStringLiteral("extensions"));
+                const QJsonArray extensionsArray = extensionsValue.toArray();
+                auto extensions = QStringList();
+                std::transform(extensionsArray.constBegin(), extensionsArray.constEnd(),
+                               std::back_inserter(extensions),
+                               [] (const QJsonValue &extensionValue) { return extensionValue.toString(); });
+                format.setExtensions(extensions);
+
+                const QString vendor = formatObject.value(QStringLiteral("vendor")).toString();
+                format.setVendor(vendor);
+
+                const QJsonValue substitutionValue = ruleObject.value(QStringLiteral("substitution"));
+                if (!substitutionValue.isString()) {
+                    qWarning() << "Substitution needs to be a string";
+                    hasError = true;
+                    break;
+                }
+
+                // We default out to a Fragment ShaderType if nothing is specified
+                // as that was the initial behavior we introduced
+                const QString shaderType = formatObject.value(QStringLiteral("shaderType")).toString();
+                format.setShaderType(shaderType == QStringLiteral("Fragment") ? QShaderFormat::Fragment
+                                   : shaderType == QStringLiteral("Vertex") ? QShaderFormat::Vertex
+                                   : shaderType == QStringLiteral("TessellationControl") ? QShaderFormat::TessellationControl
+                                   : shaderType == QStringLiteral("TessellationEvaluation") ? QShaderFormat::TessellationEvaluation
+                                   : shaderType == QStringLiteral("Geometry") ? QShaderFormat::Geometry
+                                   : shaderType == QStringLiteral("Compute") ? QShaderFormat::Compute
+                                   : QShaderFormat::Fragment);
+
+                const QByteArray substitution = substitutionValue.toString().toUtf8();
+
+                const QJsonValue snippetsValue = ruleObject.value(QStringLiteral("headerSnippets"));
+                const QJsonArray snippetsArray = snippetsValue.toArray();
+                auto snippets = QByteArrayList();
+                std::transform(snippetsArray.constBegin(), snippetsArray.constEnd(),
+                               std::back_inserter(snippets),
+                               [] (const QJsonValue &snippetValue) { return snippetValue.toString().toUtf8(); });
+
+                node.addRule(format, QShaderNode::Rule(substitution, snippets));
+            }
+        }
+
+        m_nodes.insert(property, node);
+    }
+
+    if (hasError) {
+        m_status = Error;
+        m_nodes.clear();
+    } else {
+        m_status = Ready;
+    }
+}
+}
+QT_END_NAMESPACE
diff --git a/src/render/shadergraph/qshadernodesloader_p.h b/src/render/shadergraph/qshadernodesloader_p.h
new file mode 100644
index 000000000..80d75a0bc
--- /dev/null
+++ b/src/render/shadergraph/qshadernodesloader_p.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtGui 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 The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QSHADERNODESLOADER_P_H
+#define QT3DRENDER_QSHADERNODESLOADER_P_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.
+//
+
+#include <Qt3DRender/private/qt3drender_global_p.h>
+
+#include <Qt3DRender/private/qshadergraph_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+
+namespace Qt3DRender
+{
+class QShaderNodesLoader
+{
+public:
+    enum Status : char {
+        Null,
+        Waiting,
+        Ready,
+        Error
+    };
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QShaderNodesLoader() noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT Status status() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QHash<QString, QShaderNode> nodes() const noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT QIODevice *device() const noexcept;
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void setDevice(QIODevice *device) noexcept;
+
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void load();
+    Q_3DRENDERSHARED_PRIVATE_EXPORT void load(const QJsonObject &prototypesObject);
+
+private:
+    Status m_status;
+    QIODevice *m_device;
+    QHash<QString, QShaderNode> m_nodes;
+};
+
+
+}
+Q_DECLARE_TYPEINFO(Qt3DRender::QShaderNodesLoader, Q_MOVABLE_TYPE);
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::QShaderNodesLoader)
+Q_DECLARE_METATYPE(Qt3DRender::QShaderNodesLoader::Status)
+
+#endif // QT3DRENDER_QSHADERNODESLOADER_P_H
diff --git a/src/render/shadergraph/shadergraph.pri b/src/render/shadergraph/shadergraph.pri
new file mode 100644
index 000000000..27bb8c6e9
--- /dev/null
+++ b/src/render/shadergraph/shadergraph.pri
@@ -0,0 +1,21 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/qshaderformat_p.h \
+    $$PWD/qshadergenerator_p.h \
+    $$PWD/qshadergraphloader_p.h \
+    $$PWD/qshadergraph_p.h \
+    $$PWD/qshaderlanguage_p.h \
+    $$PWD/qshadernode_p.h \
+    $$PWD/qshadernodeport_p.h \
+    $$PWD/qshadernodesloader_p.h
+
+SOURCES += \
+    $$PWD/qshaderformat.cpp \
+    $$PWD/qshadergenerator.cpp \
+    $$PWD/qshadergraph.cpp \
+    $$PWD/qshadergraphloader.cpp \
+    $$PWD/qshaderlanguage.cpp \
+    $$PWD/qshadernode.cpp \
+    $$PWD/qshadernodeport.cpp \
+    $$PWD/qshadernodesloader.cpp