Have all the Phong variations based on a graph

This commit introduces a new layered graph file to deal with all the
Phong material variations. It ports all the materials to using it, then
of course it removes all the old frag implementations.

Change-Id: Ia519eaf4cea3b6e3ff4dd5aa1cca2bedbfcbe7cb
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

25 files changed, 609 insertions, 307 deletions

diff --git a/src/extras/defaults/qdiffusemapmaterial.cpp b/src/extras/defaults/qdiffusemapmaterial.cpp
index 930fbbd1f..29e8586e3 100644
--- a/src/extras/defaults/qdiffusemapmaterial.cpp
+++ b/src/extras/defaults/qdiffusemapmaterial.cpp
@@ -46,6 +46,7 @@
 #include <Qt3DRender/qtexture.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
@@ -75,7 +76,9 @@ QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate()
     , m_diffuseMapGL2RenderPass(new QRenderPass())
     , m_diffuseMapES2RenderPass(new QRenderPass())
     , m_diffuseMapGL3Shader(new QShaderProgram())
+    , m_diffuseMapGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_diffuseMapGL2ES2Shader(new QShaderProgram())
+    , m_diffuseMapGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_filterKey(new QFilterKey)
 {
     m_diffuseTexture->setMagnificationFilter(QAbstractTexture::Linear);
@@ -87,6 +90,8 @@ QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate()
 
 void QDiffuseMapMaterialPrivate::init()
 {
+    Q_Q(QDiffuseMapMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QDiffuseMapMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -99,9 +104,20 @@ void QDiffuseMapMaterialPrivate::init()
             this, &QDiffuseMapMaterialPrivate::handleTextureScaleChanged);
 
     m_diffuseMapGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_diffuseMapGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusemap.frag"))));
+    m_diffuseMapGL3ShaderBuilder->setParent(q);
+    m_diffuseMapGL3ShaderBuilder->setShaderProgram(m_diffuseMapGL3Shader);
+    m_diffuseMapGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_diffuseMapGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                    QStringLiteral("specular"),
+                                                    QStringLiteral("normal")});
+
     m_diffuseMapGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_diffuseMapGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/diffusemap.frag"))));
+    m_diffuseMapGL2ES2ShaderBuilder->setParent(q);
+    m_diffuseMapGL2ES2ShaderBuilder->setShaderProgram(m_diffuseMapGL2ES2Shader);
+    m_diffuseMapGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_diffuseMapGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                       QStringLiteral("specular"),
+                                                       QStringLiteral("normal")});
 
     m_diffuseMapGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_diffuseMapGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -118,7 +134,6 @@ void QDiffuseMapMaterialPrivate::init()
     m_diffuseMapES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_diffuseMapES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QDiffuseMapMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qdiffusemapmaterial_p.h b/src/extras/defaults/qdiffusemapmaterial_p.h
index c0bcc01eb..cef75a3f0 100644
--- a/src/extras/defaults/qdiffusemapmaterial_p.h
+++ b/src/extras/defaults/qdiffusemapmaterial_p.h
@@ -63,6 +63,7 @@ class QAbstractTexture;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 
 } // namespace Qt3DRender
@@ -97,7 +98,9 @@ class QDiffuseMapMaterialPrivate : public Qt3DRender::QMaterialPrivate
     Qt3DRender::QRenderPass *m_diffuseMapGL2RenderPass;
     Qt3DRender::QRenderPass *m_diffuseMapES2RenderPass;
     Qt3DRender::QShaderProgram *m_diffuseMapGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_diffuseMapGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_diffuseMapGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_diffuseMapGL2ES2ShaderBuilder;
     Qt3DRender::QFilterKey *m_filterKey;
 
     Q_DECLARE_PUBLIC(QDiffuseMapMaterial)
diff --git a/src/extras/defaults/qdiffusespecularmapmaterial.cpp b/src/extras/defaults/qdiffusespecularmapmaterial.cpp
index 2e98bc8e7..cc5facd8c 100644
--- a/src/extras/defaults/qdiffusespecularmapmaterial.cpp
+++ b/src/extras/defaults/qdiffusespecularmapmaterial.cpp
@@ -46,6 +46,7 @@
 #include <Qt3DRender/qtexture.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
@@ -76,7 +77,9 @@ QDiffuseSpecularMapMaterialPrivate::QDiffuseSpecularMapMaterialPrivate()
     , m_diffuseSpecularMapGL2RenderPass(new QRenderPass())
     , m_diffuseSpecularMapES2RenderPass(new QRenderPass())
     , m_diffuseSpecularMapGL3Shader(new QShaderProgram())
+    , m_diffuseSpecularMapGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_diffuseSpecularMapGL2ES2Shader(new QShaderProgram())
+    , m_diffuseSpecularMapGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_filterKey(new QFilterKey)
 {
     m_diffuseTexture->setMagnificationFilter(QAbstractTexture::Linear);
@@ -94,6 +97,8 @@ QDiffuseSpecularMapMaterialPrivate::QDiffuseSpecularMapMaterialPrivate()
 
 void QDiffuseSpecularMapMaterialPrivate::init()
 {
+    Q_Q(QDiffuseSpecularMapMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QDiffuseSpecularMapMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -106,9 +111,20 @@ void QDiffuseSpecularMapMaterialPrivate::init()
             this, &QDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged);
 
     m_diffuseSpecularMapGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_diffuseSpecularMapGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusespecularmap.frag"))));
+    m_diffuseSpecularMapGL3ShaderBuilder->setParent(q);
+    m_diffuseSpecularMapGL3ShaderBuilder->setShaderProgram(m_diffuseSpecularMapGL3Shader);
+    m_diffuseSpecularMapGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_diffuseSpecularMapGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                            QStringLiteral("specularTexture"),
+                                                            QStringLiteral("normal")});
+
     m_diffuseSpecularMapGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_diffuseSpecularMapGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/diffusespecularmap.frag"))));
+    m_diffuseSpecularMapGL2ES2ShaderBuilder->setParent(q);
+    m_diffuseSpecularMapGL2ES2ShaderBuilder->setShaderProgram(m_diffuseSpecularMapGL2ES2Shader);
+    m_diffuseSpecularMapGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_diffuseSpecularMapGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                               QStringLiteral("specularTexture"),
+                                                               QStringLiteral("normal")});
 
     m_diffuseSpecularMapGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_diffuseSpecularMapGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -125,7 +141,6 @@ void QDiffuseSpecularMapMaterialPrivate::init()
     m_diffuseSpecularMapES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_diffuseSpecularMapES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QDiffuseSpecularMapMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qdiffusespecularmapmaterial_p.h b/src/extras/defaults/qdiffusespecularmapmaterial_p.h
index b358e088a..f80922dff 100644
--- a/src/extras/defaults/qdiffusespecularmapmaterial_p.h
+++ b/src/extras/defaults/qdiffusespecularmapmaterial_p.h
@@ -63,6 +63,7 @@ class QAbstractTexture;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 
 } // namespace Qt3DRender
@@ -99,7 +100,9 @@ public:
     Qt3DRender::QRenderPass *m_diffuseSpecularMapGL2RenderPass;
     Qt3DRender::QRenderPass *m_diffuseSpecularMapES2RenderPass;
     Qt3DRender::QShaderProgram *m_diffuseSpecularMapGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_diffuseSpecularMapGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_diffuseSpecularMapGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_diffuseSpecularMapGL2ES2ShaderBuilder;
     Qt3DRender::QFilterKey *m_filterKey;
 
     Q_DECLARE_PUBLIC(QDiffuseSpecularMapMaterial)
diff --git a/src/extras/defaults/qnormaldiffusemapalphamaterial.cpp b/src/extras/defaults/qnormaldiffusemapalphamaterial.cpp
index dd8288683..c276c9717 100644
--- a/src/extras/defaults/qnormaldiffusemapalphamaterial.cpp
+++ b/src/extras/defaults/qnormaldiffusemapalphamaterial.cpp
@@ -45,6 +45,7 @@
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
 #include <Qt3DRender/qalphacoverage.h>
@@ -69,6 +70,8 @@ QNormalDiffuseMapAlphaMaterialPrivate::QNormalDiffuseMapAlphaMaterialPrivate()
 
 void QNormalDiffuseMapAlphaMaterialPrivate::init()
 {
+    Q_Q(QNormalDiffuseMapMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QNormalDiffuseMapMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -83,9 +86,20 @@ void QNormalDiffuseMapAlphaMaterialPrivate::init()
             this, &QNormalDiffuseMapMaterialPrivate::handleTextureScaleChanged);
 
     m_normalDiffuseGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_normalDiffuseGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusemap.frag"))));
+    m_normalDiffuseGL3ShaderBuilder->setParent(q);
+    m_normalDiffuseGL3ShaderBuilder->setShaderProgram(m_normalDiffuseGL3Shader);
+    m_normalDiffuseGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                       QStringLiteral("specular"),
+                                                       QStringLiteral("normalTexture")});
+
     m_normalDiffuseGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_normalDiffuseGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/normaldiffusemap.frag"))));
+    m_normalDiffuseGL2ES2ShaderBuilder->setParent(q);
+    m_normalDiffuseGL2ES2ShaderBuilder->setShaderProgram(m_normalDiffuseGL2ES2Shader);
+    m_normalDiffuseGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                          QStringLiteral("specular"),
+                                                          QStringLiteral("normalTexture")});
 
     m_normalDiffuseGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_normalDiffuseGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -102,7 +116,6 @@ void QNormalDiffuseMapAlphaMaterialPrivate::init()
     m_normalDiffuseES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_normalDiffuseES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QNormalDiffuseMapMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qnormaldiffusemapmaterial.cpp b/src/extras/defaults/qnormaldiffusemapmaterial.cpp
index ec3bd0a22..687e59751 100644
--- a/src/extras/defaults/qnormaldiffusemapmaterial.cpp
+++ b/src/extras/defaults/qnormaldiffusemapmaterial.cpp
@@ -46,6 +46,7 @@
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
 #include <QtCore/QUrl>
@@ -76,7 +77,9 @@ QNormalDiffuseMapMaterialPrivate::QNormalDiffuseMapMaterialPrivate()
     , m_normalDiffuseGL2RenderPass(new QRenderPass())
     , m_normalDiffuseES2RenderPass(new QRenderPass())
     , m_normalDiffuseGL3Shader(new QShaderProgram())
+    , m_normalDiffuseGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_normalDiffuseGL2ES2Shader(new QShaderProgram())
+    , m_normalDiffuseGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_filterKey(new QFilterKey)
 {
     m_diffuseTexture->setMagnificationFilter(QAbstractTexture::Linear);
@@ -94,6 +97,8 @@ QNormalDiffuseMapMaterialPrivate::QNormalDiffuseMapMaterialPrivate()
 
 void QNormalDiffuseMapMaterialPrivate::init()
 {
+    Q_Q(QNormalDiffuseMapMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QNormalDiffuseMapMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -108,9 +113,20 @@ void QNormalDiffuseMapMaterialPrivate::init()
             this, &QNormalDiffuseMapMaterialPrivate::handleTextureScaleChanged);
 
     m_normalDiffuseGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_normalDiffuseGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusemap.frag"))));
+    m_normalDiffuseGL3ShaderBuilder->setParent(q);
+    m_normalDiffuseGL3ShaderBuilder->setShaderProgram(m_normalDiffuseGL3Shader);
+    m_normalDiffuseGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                       QStringLiteral("specular"),
+                                                       QStringLiteral("normalTexture")});
+
     m_normalDiffuseGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_normalDiffuseGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/normaldiffusemap.frag"))));
+    m_normalDiffuseGL2ES2ShaderBuilder->setParent(q);
+    m_normalDiffuseGL2ES2ShaderBuilder->setShaderProgram(m_normalDiffuseGL2ES2Shader);
+    m_normalDiffuseGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                          QStringLiteral("specular"),
+                                                          QStringLiteral("normalTexture")});
 
     m_normalDiffuseGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_normalDiffuseGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -127,7 +143,6 @@ void QNormalDiffuseMapMaterialPrivate::init()
     m_normalDiffuseES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_normalDiffuseES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QNormalDiffuseMapMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qnormaldiffusemapmaterial_p.h b/src/extras/defaults/qnormaldiffusemapmaterial_p.h
index d88b01f1f..1ac937b1e 100644
--- a/src/extras/defaults/qnormaldiffusemapmaterial_p.h
+++ b/src/extras/defaults/qnormaldiffusemapmaterial_p.h
@@ -63,6 +63,7 @@ class QAbstractTexture;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 
 } // namespace Qt3DRender
@@ -101,7 +102,9 @@ public:
     Qt3DRender::QRenderPass *m_normalDiffuseGL2RenderPass;
     Qt3DRender::QRenderPass *m_normalDiffuseES2RenderPass;
     Qt3DRender::QShaderProgram *m_normalDiffuseGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_normalDiffuseGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_normalDiffuseGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_normalDiffuseGL2ES2ShaderBuilder;
     Qt3DRender::QFilterKey *m_filterKey;
 
     Q_DECLARE_PUBLIC(QNormalDiffuseMapMaterial)
diff --git a/src/extras/defaults/qnormaldiffusespecularmapmaterial.cpp b/src/extras/defaults/qnormaldiffusespecularmapmaterial.cpp
index eaa1491a0..7665c07a7 100644
--- a/src/extras/defaults/qnormaldiffusespecularmapmaterial.cpp
+++ b/src/extras/defaults/qnormaldiffusespecularmapmaterial.cpp
@@ -46,6 +46,7 @@
 #include <Qt3DRender/qtexture.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
@@ -78,7 +79,9 @@ QNormalDiffuseSpecularMapMaterialPrivate::QNormalDiffuseSpecularMapMaterialPriva
     , m_normalDiffuseSpecularGL2RenderPass(new QRenderPass())
     , m_normalDiffuseSpecularES2RenderPass(new QRenderPass())
     , m_normalDiffuseSpecularGL3Shader(new QShaderProgram())
+    , m_normalDiffuseSpecularGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_normalDiffuseSpecularGL2ES2Shader(new QShaderProgram())
+    , m_normalDiffuseSpecularGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_filterKey(new QFilterKey)
 {
     m_diffuseTexture->setMagnificationFilter(QAbstractTexture::Linear);
@@ -102,6 +105,8 @@ QNormalDiffuseSpecularMapMaterialPrivate::QNormalDiffuseSpecularMapMaterialPriva
 
 void QNormalDiffuseSpecularMapMaterialPrivate::init()
 {
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QNormalDiffuseSpecularMapMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -116,9 +121,20 @@ void QNormalDiffuseSpecularMapMaterialPrivate::init()
             this, &QNormalDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged);
 
     m_normalDiffuseSpecularGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_normalDiffuseSpecularGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusespecularmap.frag"))));
+    m_normalDiffuseSpecularGL3ShaderBuilder->setParent(q);
+    m_normalDiffuseSpecularGL3ShaderBuilder->setShaderProgram(m_normalDiffuseSpecularGL3Shader);
+    m_normalDiffuseSpecularGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseSpecularGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                               QStringLiteral("specularTexture"),
+                                                               QStringLiteral("normalTexture")});
+
     m_normalDiffuseSpecularGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_normalDiffuseSpecularGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/normaldiffusespecularmap.frag"))));
+    m_normalDiffuseSpecularGL2ES2ShaderBuilder->setParent(q);
+    m_normalDiffuseSpecularGL2ES2ShaderBuilder->setShaderProgram(m_normalDiffuseSpecularGL2ES2Shader);
+    m_normalDiffuseSpecularGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_normalDiffuseSpecularGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
+                                                                  QStringLiteral("specularTexture"),
+                                                                  QStringLiteral("normalTexture")});
 
     m_normalDiffuseSpecularGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_normalDiffuseSpecularGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -135,7 +151,6 @@ void QNormalDiffuseSpecularMapMaterialPrivate::init()
     m_normalDiffuseSpecularES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_normalDiffuseSpecularES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QNormalDiffuseSpecularMapMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qnormaldiffusespecularmapmaterial_p.h b/src/extras/defaults/qnormaldiffusespecularmapmaterial_p.h
index 3316044ff..e02451cc0 100644
--- a/src/extras/defaults/qnormaldiffusespecularmapmaterial_p.h
+++ b/src/extras/defaults/qnormaldiffusespecularmapmaterial_p.h
@@ -63,6 +63,7 @@ class QAbstractTexture;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 
 } // namespace Qt3DRender
@@ -102,7 +103,9 @@ public:
     Qt3DRender::QRenderPass *m_normalDiffuseSpecularGL2RenderPass;
     Qt3DRender::QRenderPass *m_normalDiffuseSpecularES2RenderPass;
     Qt3DRender::QShaderProgram *m_normalDiffuseSpecularGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_normalDiffuseSpecularGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_normalDiffuseSpecularGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_normalDiffuseSpecularGL2ES2ShaderBuilder;
     Qt3DRender::QFilterKey *m_filterKey;
 
     Q_DECLARE_PUBLIC(QNormalDiffuseSpecularMapMaterial)
diff --git a/src/extras/defaults/qphongalphamaterial.cpp b/src/extras/defaults/qphongalphamaterial.cpp
index fd8c52525..fb0871ee4 100644
--- a/src/extras/defaults/qphongalphamaterial.cpp
+++ b/src/extras/defaults/qphongalphamaterial.cpp
@@ -45,6 +45,7 @@
 #include <Qt3DRender/qeffect.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
@@ -75,7 +76,9 @@ QPhongAlphaMaterialPrivate::QPhongAlphaMaterialPrivate()
     , m_phongAlphaGL2RenderPass(new QRenderPass())
     , m_phongAlphaES2RenderPass(new QRenderPass())
     , m_phongAlphaGL3Shader(new QShaderProgram())
+    , m_phongAlphaGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_phongAlphaGL2ES2Shader(new QShaderProgram())
+    , m_phongAlphaGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_noDepthMask(new QNoDepthMask())
     , m_blendState(new QBlendEquationArguments())
     , m_blendEquation(new QBlendEquation())
@@ -86,6 +89,8 @@ QPhongAlphaMaterialPrivate::QPhongAlphaMaterialPrivate()
 // TODO: Define how lights are properties are set in the shaders. Ideally using a QShaderData
 void QPhongAlphaMaterialPrivate::init()
 {
+    Q_Q(QPhongAlphaMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QPhongAlphaMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -96,9 +101,20 @@ void QPhongAlphaMaterialPrivate::init()
             this, &QPhongAlphaMaterialPrivate::handleShininessChanged);
 
     m_phongAlphaGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_phongAlphaGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.frag"))));
+    m_phongAlphaGL3ShaderBuilder->setParent(q);
+    m_phongAlphaGL3ShaderBuilder->setShaderProgram(m_phongAlphaGL3Shader);
+    m_phongAlphaGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_phongAlphaGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuse"),
+                                                    QStringLiteral("specular"),
+                                                    QStringLiteral("normal")});
+
     m_phongAlphaGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_phongAlphaGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.frag"))));
+    m_phongAlphaGL2ES2ShaderBuilder->setParent(q);
+    m_phongAlphaGL2ES2ShaderBuilder->setShaderProgram(m_phongAlphaGL2ES2Shader);
+    m_phongAlphaGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_phongAlphaGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuse"),
+                                                       QStringLiteral("specular"),
+                                                       QStringLiteral("normal")});
 
     m_phongAlphaGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_phongAlphaGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -115,7 +131,6 @@ void QPhongAlphaMaterialPrivate::init()
     m_phongAlphaES2Technique->graphicsApiFilter()->setMinorVersion(0);
     m_phongAlphaES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
 
-    Q_Q(QPhongAlphaMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qphongalphamaterial_p.h b/src/extras/defaults/qphongalphamaterial_p.h
index 84e2eead3..97eaf7bc4 100644
--- a/src/extras/defaults/qphongalphamaterial_p.h
+++ b/src/extras/defaults/qphongalphamaterial_p.h
@@ -62,6 +62,7 @@ class QEffect;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 class QNoDepthMask;
 class QBlendEquationArguments;
@@ -97,7 +98,9 @@ public:
     Qt3DRender::QRenderPass *m_phongAlphaGL2RenderPass;
     Qt3DRender::QRenderPass *m_phongAlphaES2RenderPass;
     Qt3DRender::QShaderProgram *m_phongAlphaGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_phongAlphaGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_phongAlphaGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_phongAlphaGL2ES2ShaderBuilder;
     Qt3DRender::QNoDepthMask *m_noDepthMask;
     Qt3DRender::QBlendEquationArguments *m_blendState;
     Qt3DRender::QBlendEquation *m_blendEquation;
diff --git a/src/extras/defaults/qphongmaterial.cpp b/src/extras/defaults/qphongmaterial.cpp
index 25dbf3c85..c76e3a6ef 100644
--- a/src/extras/defaults/qphongmaterial.cpp
+++ b/src/extras/defaults/qphongmaterial.cpp
@@ -45,6 +45,7 @@
 #include <Qt3DRender/qeffect.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qshaderprogram.h>
+#include <Qt3DRender/qshaderprogrambuilder.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qrenderpass.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
@@ -73,13 +74,17 @@ QPhongMaterialPrivate::QPhongMaterialPrivate()
     , m_phongGL2RenderPass(new QRenderPass())
     , m_phongES2RenderPass(new QRenderPass())
     , m_phongGL3Shader(new QShaderProgram())
+    , m_phongGL3ShaderBuilder(new QShaderProgramBuilder())
     , m_phongGL2ES2Shader(new QShaderProgram())
+    , m_phongGL2ES2ShaderBuilder(new QShaderProgramBuilder())
     , m_filterKey(new QFilterKey)
 {
 }
 
 void QPhongMaterialPrivate::init()
 {
+    Q_Q(QPhongMaterial);
+
     connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
             this, &QPhongMaterialPrivate::handleAmbientChanged);
     connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
@@ -90,9 +95,20 @@ void QPhongMaterialPrivate::init()
             this, &QPhongMaterialPrivate::handleShininessChanged);
 
     m_phongGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
-    m_phongGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.frag"))));
+    m_phongGL3ShaderBuilder->setParent(q);
+    m_phongGL3ShaderBuilder->setShaderProgram(m_phongGL3Shader);
+    m_phongGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_phongGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuse"),
+                                               QStringLiteral("specular"),
+                                               QStringLiteral("normal")});
+
     m_phongGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
-    m_phongGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.frag"))));
+    m_phongGL2ES2ShaderBuilder->setParent(q);
+    m_phongGL2ES2ShaderBuilder->setShaderProgram(m_phongGL2ES2Shader);
+    m_phongGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
+    m_phongGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuse"),
+                                                  QStringLiteral("specular"),
+                                                  QStringLiteral("normal")});
 
     m_phongGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
     m_phongGL3Technique->graphicsApiFilter()->setMajorVersion(3);
@@ -117,7 +133,6 @@ void QPhongMaterialPrivate::init()
     m_phongGL2Technique->addRenderPass(m_phongGL2RenderPass);
     m_phongES2Technique->addRenderPass(m_phongES2RenderPass);
 
-    Q_Q(QPhongMaterial);
     m_filterKey->setParent(q);
     m_filterKey->setName(QStringLiteral("renderingStyle"));
     m_filterKey->setValue(QStringLiteral("forward"));
diff --git a/src/extras/defaults/qphongmaterial_p.h b/src/extras/defaults/qphongmaterial_p.h
index bc6d0ce44..f1e55242b 100644
--- a/src/extras/defaults/qphongmaterial_p.h
+++ b/src/extras/defaults/qphongmaterial_p.h
@@ -62,6 +62,7 @@ class QEffect;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
+class QShaderProgramBuilder;
 class QRenderPass;
 
 } // namespace Qt3DRender
@@ -94,7 +95,9 @@ public:
     Qt3DRender::QRenderPass *m_phongGL2RenderPass;
     Qt3DRender::QRenderPass *m_phongES2RenderPass;
     Qt3DRender::QShaderProgram *m_phongGL3Shader;
+    Qt3DRender::QShaderProgramBuilder *m_phongGL3ShaderBuilder;
     Qt3DRender::QShaderProgram *m_phongGL2ES2Shader;
+    Qt3DRender::QShaderProgramBuilder *m_phongGL2ES2ShaderBuilder;
     Qt3DRender::QFilterKey *m_filterKey;
 
     Q_DECLARE_PUBLIC(QPhongMaterial)
diff --git a/src/extras/extras.qrc b/src/extras/extras.qrc
index f3619fdb7..bfb14f3f9 100644
--- a/src/extras/extras.qrc
+++ b/src/extras/extras.qrc
@@ -1,6 +1,7 @@
 <RCC>
     <qresource prefix="/">
         <file>shaders/graphs/metalrough.frag.json</file>
+        <file>shaders/graphs/phong.frag.json</file>
         <file>shaders/gl3/light.inc.frag</file>
         <file>shaders/es2/light.inc.frag</file>
         <file>shaders/es2/light.inc.frag100</file>
@@ -10,16 +11,6 @@
         <file>shaders/gl3/metalrough.inc.frag</file>
         <file>shaders/gl3/coordinatesystems.inc</file>
         <file>shaders/es2/coordinatesystems.inc</file>
-        <file>shaders/gl3/phong.frag</file>
-        <file>shaders/es2/phong.frag</file>
-        <file>shaders/gl3/normaldiffusespecularmap.frag</file>
-        <file>shaders/gl3/diffusemap.frag</file>
-        <file>shaders/es2/normaldiffusespecularmap.frag</file>
-        <file>shaders/es2/diffusemap.frag</file>
-        <file>shaders/es2/normaldiffusemap.frag</file>
-        <file>shaders/gl3/normaldiffusemap.frag</file>
-        <file>shaders/es2/diffusespecularmap.frag</file>
-        <file>shaders/gl3/diffusespecularmap.frag</file>
         <file>shaders/gl3/default.vert</file>
         <file>shaders/es2/default.vert</file>
         <file>shaders/gl3/pervertexcolor.frag</file>
diff --git a/src/extras/shaders/es2/diffusemap.frag b/src/extras/shaders/es2/diffusemap.frag
deleted file mode 100644
index 6ac9bd5a3..000000000
--- a/src/extras/shaders/es2/diffusemap.frag
+++ /dev/null
@@ -1,22 +0,0 @@
-#define FP highp
-
-uniform FP vec4 ka;            // Ambient reflectivity
-uniform FP vec4 ks;            // Specular reflectivity
-uniform FP float shininess;    // Specular shininess factor
-
-uniform FP vec3 eyePosition;
-
-uniform sampler2D diffuseTexture;
-
-varying FP vec3 worldPosition;
-varying FP vec3 worldNormal;
-varying FP vec2 texCoord;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
-    FP vec3 worldView = normalize(eyePosition - worldPosition);
-    gl_FragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/es2/diffusespecularmap.frag b/src/extras/shaders/es2/diffusespecularmap.frag
deleted file mode 100644
index 99183aaf4..000000000
--- a/src/extras/shaders/es2/diffusespecularmap.frag
+++ /dev/null
@@ -1,24 +0,0 @@
-#define FP highp
-
-// TODO: Replace with a struct
-uniform FP vec4 ka;            // Ambient reflectivity
-uniform FP float shininess;    // Specular shininess factor
-
-uniform FP vec3 eyePosition;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D specularTexture;
-
-varying FP vec3 worldPosition;
-varying FP vec3 worldNormal;
-varying FP vec2 texCoord;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
-    FP vec4 specularTextureColor = texture2D( specularTexture, texCoord );
-    FP vec3 worldView = normalize(eyePosition - worldPosition);
-    gl_FragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/es2/normaldiffusemap.frag b/src/extras/shaders/es2/normaldiffusemap.frag
deleted file mode 100644
index 0bf4c5630..000000000
--- a/src/extras/shaders/es2/normaldiffusemap.frag
+++ /dev/null
@@ -1,34 +0,0 @@
-#define FP highp
-
-varying FP vec3 worldPosition;
-varying FP vec3 worldNormal;
-varying FP vec4 worldTangent;
-varying FP vec2 texCoord;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D normalTexture;
-
-// TODO: Replace with a struct
-uniform FP vec4 ka;            // Ambient reflectivity
-uniform FP vec4 ks;            // Specular reflectivity
-uniform FP float shininess;    // Specular shininess factor
-
-uniform FP vec3 eyePosition;
-
-#pragma include phong.inc.frag
-#pragma include coordinatesystems.inc
-
-void main()
-{
-    // Sample the textures at the interpolated texCoords
-    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
-    FP vec3 tNormal = 2.0 * texture2D( normalTexture, texCoord ).rgb - vec3( 1.0 );
-
-    FP mat3 tangentMatrix = calcWorldSpaceToTangentSpaceMatrix(worldNormal, worldTangent);
-    FP mat3 invertTangentMatrix = transpose(tangentMatrix);
-
-    FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
-    FP vec3 worldView = normalize(eyePosition - worldPosition);
-
-    gl_FragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
-}
diff --git a/src/extras/shaders/es2/normaldiffusespecularmap.frag b/src/extras/shaders/es2/normaldiffusespecularmap.frag
deleted file mode 100644
index 0541c8902..000000000
--- a/src/extras/shaders/es2/normaldiffusespecularmap.frag
+++ /dev/null
@@ -1,35 +0,0 @@
-#define FP highp
-
-varying FP vec3 worldPosition;
-varying FP vec3 worldNormal;
-varying FP vec4 worldTangent;
-varying FP vec2 texCoord;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D specularTexture;
-uniform sampler2D normalTexture;
-
-// TODO: Replace with a struct
-uniform FP vec4 ka;            // Ambient reflectivity
-uniform FP float shininess;    // Specular shininess factor
-
-uniform FP vec3 eyePosition;
-
-#pragma include phong.inc.frag
-#pragma include coordinatesystems.inc
-
-void main()
-{
-    // Sample the textures at the interpolated texCoords
-    FP vec4 diffuseTextureColor = texture2D( diffuseTexture, texCoord );
-    FP vec4 specularTextureColor = texture2D( specularTexture, texCoord );
-    FP vec3 tNormal = 2.0 * texture2D( normalTexture, texCoord ).rgb - vec3( 1.0 );
-
-    FP mat3 tangentMatrix = calcWorldSpaceToTangentSpaceMatrix(worldNormal, worldTangent);
-    FP mat3 invertTangentMatrix = transpose(tangentMatrix);
-
-    FP vec3 wNormal = normalize(invertTangentMatrix * tNormal);
-    FP vec3 worldView = normalize(eyePosition - worldPosition);
-
-    gl_FragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, wNormal);
-}
diff --git a/src/extras/shaders/es2/phong.frag b/src/extras/shaders/es2/phong.frag
deleted file mode 100644
index 6b8ab7111..000000000
--- a/src/extras/shaders/es2/phong.frag
+++ /dev/null
@@ -1,19 +0,0 @@
-#define FP highp
-
-uniform FP vec4 ka;            // Ambient reflectivity
-uniform FP vec4 kd;            // Diffuse reflectivity
-uniform FP vec4 ks;            // Specular reflectivity
-uniform FP float shininess;    // Specular shininess factor
-
-uniform FP vec3 eyePosition;
-
-varying FP vec3 worldPosition;
-varying FP vec3 worldNormal;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    FP vec3 worldView = normalize(eyePosition - worldPosition);
-    gl_FragColor = phongFunction(ka, kd, ks, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/gl3/diffusemap.frag b/src/extras/shaders/gl3/diffusemap.frag
deleted file mode 100644
index 34fef5a43..000000000
--- a/src/extras/shaders/gl3/diffusemap.frag
+++ /dev/null
@@ -1,24 +0,0 @@
-#version 150 core
-
-uniform vec4 ka;            // Ambient reflectivity
-uniform vec4 ks;            // Specular reflectivity
-uniform float shininess;    // Specular shininess factor
-
-uniform vec3 eyePosition;
-
-uniform sampler2D diffuseTexture;
-
-in vec3 worldPosition;
-in vec3 worldNormal;
-in vec2 texCoord;
-
-out vec4 fragColor;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
-    vec3 worldView = normalize(eyePosition - worldPosition);
-    fragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/gl3/diffusespecularmap.frag b/src/extras/shaders/gl3/diffusespecularmap.frag
deleted file mode 100644
index 8673a5121..000000000
--- a/src/extras/shaders/gl3/diffusespecularmap.frag
+++ /dev/null
@@ -1,26 +0,0 @@
-#version 150 core
-
-// TODO: Replace with a struct
-uniform vec4 ka;            // Ambient reflectivity
-uniform float shininess;    // Specular shininess factor
-
-uniform vec3 eyePosition;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D specularTexture;
-
-in vec3 worldPosition;
-in vec3 worldNormal;
-in vec2 texCoord;
-
-out vec4 fragColor;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
-    vec4 specularTextureColor = texture( specularTexture, texCoord );
-    vec3 worldView = normalize(eyePosition - worldPosition);
-    fragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/gl3/normaldiffusemap.frag b/src/extras/shaders/gl3/normaldiffusemap.frag
deleted file mode 100644
index bac776738..000000000
--- a/src/extras/shaders/gl3/normaldiffusemap.frag
+++ /dev/null
@@ -1,36 +0,0 @@
-#version 150 core
-
-in vec3 worldPosition;
-in vec3 worldNormal;
-in vec4 worldTangent;
-in vec2 texCoord;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D normalTexture;
-
-// TODO: Replace with a struct
-uniform vec4 ka;            // Ambient reflectivity
-uniform vec4 ks;            // Specular reflectivity
-uniform float shininess;    // Specular shininess factor
-
-uniform vec3 eyePosition;
-
-out vec4 fragColor;
-
-#pragma include phong.inc.frag
-#pragma include coordinatesystems.inc
-
-void main()
-{
-    // Sample the textures at the interpolated texCoords
-    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
-    vec3 tNormal = 2.0 * texture( normalTexture, texCoord ).rgb - vec3( 1.0 );
-
-    mat3 tangentMatrix = calcWorldSpaceToTangentSpaceMatrix(worldNormal, worldTangent);
-    mat3 invertTangentMatrix = transpose(tangentMatrix);
-
-    vec3 wNormal = normalize(invertTangentMatrix * tNormal);
-
-    vec3 worldView = normalize(eyePosition - worldPosition);
-    fragColor = phongFunction(ka, diffuseTextureColor, ks, shininess, worldPosition, worldView, wNormal);
-}
diff --git a/src/extras/shaders/gl3/normaldiffusespecularmap.frag b/src/extras/shaders/gl3/normaldiffusespecularmap.frag
deleted file mode 100644
index d96b9e747..000000000
--- a/src/extras/shaders/gl3/normaldiffusespecularmap.frag
+++ /dev/null
@@ -1,35 +0,0 @@
-#version 150 core
-
-in vec3 worldPosition;
-in vec3 worldNormal;
-in vec4 worldTangent;
-in vec2 texCoord;
-
-out vec4 fragColor;
-
-uniform sampler2D diffuseTexture;
-uniform sampler2D specularTexture;
-uniform sampler2D normalTexture;
-
-uniform vec4 ka;            // Ambient reflectivity
-uniform float shininess;    // Specular shininess factor
-uniform vec3 eyePosition;
-
-#pragma include phong.inc.frag
-#pragma include coordinatesystems.inc
-
-void main()
-{
-    // Sample the textures at the interpolated texCoords
-    vec4 diffuseTextureColor = texture( diffuseTexture, texCoord );
-    vec4 specularTextureColor = texture( specularTexture, texCoord );
-    vec3 tNormal = 2.0 * texture( normalTexture, texCoord ).rgb - vec3( 1.0 );
-
-    mat3 tangentMatrix = calcWorldSpaceToTangentSpaceMatrix(worldNormal, worldTangent);
-    mat3 invertTangentMatrix = transpose(tangentMatrix);
-
-    vec3 wNormal = normalize(invertTangentMatrix * tNormal);
-
-    vec3 worldView = normalize(eyePosition - worldPosition);
-    fragColor = phongFunction(ka, diffuseTextureColor, specularTextureColor, shininess, worldPosition, worldView, wNormal);
-}
diff --git a/src/extras/shaders/gl3/phong.frag b/src/extras/shaders/gl3/phong.frag
deleted file mode 100644
index 3652672b5..000000000
--- a/src/extras/shaders/gl3/phong.frag
+++ /dev/null
@@ -1,21 +0,0 @@
-#version 150 core
-
-uniform vec4 ka;            // Ambient reflectivity
-uniform vec4 kd;            // Diffuse reflectivity
-uniform vec4 ks;            // Specular reflectivity
-uniform float shininess;    // Specular shininess factor
-
-uniform vec3 eyePosition;
-
-in vec3 worldPosition;
-in vec3 worldNormal;
-
-out vec4 fragColor;
-
-#pragma include phong.inc.frag
-
-void main()
-{
-    vec3 worldView = normalize(eyePosition - worldPosition);
-    fragColor = phongFunction(ka, kd, ks, shininess, worldPosition, worldView, worldNormal);
-}
diff --git a/src/extras/shaders/graphs/phong.frag.json b/src/extras/shaders/graphs/phong.frag.json
new file mode 100644
index 000000000..dedeb1067
--- /dev/null
+++ b/src/extras/shaders/graphs/phong.frag.json
@@ -0,0 +1,466 @@
+{
+    "nodes": [
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000001}",
+            "type": "input",
+            "parameters": {
+                "name": "worldPosition",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Input"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000002}",
+            "type": "eyePosition"
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000003}",
+            "type": "input",
+            "parameters": {
+                "name": "worldNormal",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Input"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000004}",
+            "type": "input",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "name": "worldTangent",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Input"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec4"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000005}",
+            "type": "input",
+            "layers": ["diffuseTexture", "specularTexture", "normalTexture"],
+            "parameters": {
+                "name": "texCoord",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Input"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec2"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000006}",
+            "type": "input",
+            "parameters": {
+                "name": "ka",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Uniform"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec4"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000007}",
+            "type": "input",
+            "layers": ["diffuse"],
+            "parameters": {
+                "name": "kd",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Uniform"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec4"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000008}",
+            "type": "sampleTexture",
+            "layers": ["diffuseTexture"],
+            "parameters": {
+                "name": "diffuseTexture"
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000009}",
+            "type": "input",
+            "layers": ["specular"],
+            "parameters": {
+                "name": "ks",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Uniform"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec4"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000010}",
+            "layers": ["specularTexture"],
+            "type": "sampleTexture",
+            "parameters": {
+                "name": "specularTexture"
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000011}",
+            "type": "input",
+            "parameters": {
+                "name": "shininess",
+                "qualifier": {
+                    "type": "QShaderLanguage::StorageQualifier",
+                    "value": "QShaderLanguage::Uniform"
+                },
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Float"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000012}",
+            "type": "subtract",
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000013}",
+            "type": "normalize",
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000014}",
+            "type": "normalize",
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000015}",
+            "type": "worldSpaceToTangentSpaceMatrix",
+            "layers": ["normalTexture"]
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000016}",
+            "type": "transpose",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Mat3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000017}",
+            "type": "sampleTexture",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "name": "normalTexture"
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000018}",
+            "type": "swizzle",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "fields": "rgb",
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000019}",
+            "type": "constant",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "constant": "2.0",
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Float"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000020}",
+            "type": "multiply",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000021}",
+            "type": "constant",
+            "layers": ["normalTexture"],
+            "parameters": {
+                "constant": "1.0",
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000022}",
+            "type": "subtract",
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000023}",
+            "type": "multiply",
+            "parameters": {
+                "type": {
+                    "type": "QShaderLanguage::VariableType",
+                    "value": "QShaderLanguage::Vec3"
+                }
+            }
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000024}",
+            "type": "phongFunction"
+        },
+        {
+            "uuid": "{00000000-0000-0000-0000-000000000025}",
+            "type": "fragColor"
+        }
+    ],
+    "edges": [
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000001}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "worldPosition"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000001}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000012}",
+            "targetPort": "subtrahend"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000002}",
+            "sourcePort": "eyePosition",
+            "targetUuid": "{00000000-0000-0000-0000-000000000012}",
+            "targetPort": "minuend"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000012}",
+            "sourcePort": "difference",
+            "targetUuid": "{00000000-0000-0000-0000-000000000013}",
+            "targetPort": "input"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000013}",
+            "sourcePort": "output",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "worldView"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000003}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000014}",
+            "targetPort": "input",
+            "layers": ["normal"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000003}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000015}",
+            "targetPort": "worldNormal",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000004}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000015}",
+            "targetPort": "worldTangent",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000015}",
+            "sourcePort": "matrix",
+            "targetUuid": "{00000000-0000-0000-0000-000000000016}",
+            "targetPort": "input",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000016}",
+            "sourcePort": "output",
+            "targetUuid": "{00000000-0000-0000-0000-000000000023}",
+            "targetPort": "first",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000005}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000017}",
+            "targetPort": "coord",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000017}",
+            "sourcePort": "color",
+            "targetUuid": "{00000000-0000-0000-0000-000000000018}",
+            "targetPort": "input",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000018}",
+            "sourcePort": "output",
+            "targetUuid": "{00000000-0000-0000-0000-000000000020}",
+            "targetPort": "first",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000019}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000020}",
+            "targetPort": "second",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000020}",
+            "sourcePort": "product",
+            "targetUuid": "{00000000-0000-0000-0000-000000000022}",
+            "targetPort": "minuend",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000021}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000022}",
+            "targetPort": "subtrahend",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000022}",
+            "sourcePort": "difference",
+            "targetUuid": "{00000000-0000-0000-0000-000000000023}",
+            "targetPort": "second",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000023}",
+            "sourcePort": "product",
+            "targetUuid": "{00000000-0000-0000-0000-000000000014}",
+            "targetPort": "input",
+            "layers": ["normalTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000014}",
+            "sourcePort": "output",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "worldNormal"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000006}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "ambient"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000007}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "diffuse",
+            "layers": ["diffuse"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000005}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000008}",
+            "targetPort": "coord",
+            "layers": ["diffuseTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000008}",
+            "sourcePort": "color",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "diffuse",
+            "layers": ["diffuseTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000009}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "specular",
+            "layers": ["specular"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000005}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000010}",
+            "targetPort": "coord",
+            "layers": ["specularTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000010}",
+            "sourcePort": "color",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "specular",
+            "layers": ["specularTexture"]
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000011}",
+            "sourcePort": "value",
+            "targetUuid": "{00000000-0000-0000-0000-000000000024}",
+            "targetPort": "shininess"
+        },
+        {
+            "sourceUuid": "{00000000-0000-0000-0000-000000000024}",
+            "sourcePort": "outputColor",
+            "targetUuid": "{00000000-0000-0000-0000-000000000025}",
+            "targetPort": "fragColor"
+        }
+    ]
+}