Added parameters to signals and made setters Q_SLOTS

Change-Id: Icec2f9f207221e35ffdeeb594bb9b4dc6ef890f1
Task-number: QTBUG-49797
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

25 files changed, 523 insertions, 209 deletions

diff --git a/src/render/defaults/qdiffusemapmaterial.cpp b/src/render/defaults/qdiffusemapmaterial.cpp
index e46fb4e53..36bf2ea59 100644
--- a/src/render/defaults/qdiffusemapmaterial.cpp
+++ b/src/render/defaults/qdiffusemapmaterial.cpp
@@ -73,7 +73,7 @@ QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate()
     , m_diffuseMapES2RenderPass(new QRenderPass())
     , m_diffuseMapGL3Shader(new QShaderProgram())
     , m_diffuseMapGL2ES2Shader(new QShaderProgram())
- {
+{
     m_diffuseTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
     m_diffuseTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
@@ -83,6 +83,17 @@ QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate()
 
 void QDiffuseMapMaterialPrivate::init()
 {
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseMapMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseMapMaterialPrivate::handleDiffuseChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseMapMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseMapMaterialPrivate::handleShininessChanged);
+    connect(m_textureScaleParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseMapMaterialPrivate::handleTextureScaleChanged);
+
     m_diffuseMapGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusemap.vert"))));
     m_diffuseMapGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusemap.frag"))));
     m_diffuseMapGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/diffusemap.vert"))));
@@ -124,6 +135,36 @@ void QDiffuseMapMaterialPrivate::init()
     q_func()->setEffect(m_diffuseMapEffect);
 }
 
+void QDiffuseMapMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseMapMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QDiffuseMapMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseMapMaterial);
+    emit q->diffuseChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QDiffuseMapMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseMapMaterial);
+    emit q->specularChanged(var.value<QColor>());
+}
+
+void QDiffuseMapMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseMapMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
+void QDiffuseMapMaterialPrivate::handleTextureScaleChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseMapMaterial);
+    emit q->textureScaleChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QDiffuseMapMaterial
     \brief The QDiffuseMapMaterial provides a default implementation of the phong lighting effect where the diffuse light component
@@ -152,11 +193,6 @@ QDiffuseMapMaterial::QDiffuseMapMaterial(QNode *parent)
     : QMaterial(*new QDiffuseMapMaterialPrivate, parent)
 {
     Q_D(QDiffuseMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
diff --git a/src/render/defaults/qdiffusemapmaterial.h b/src/render/defaults/qdiffusemapmaterial.h
index 2f91b4efc..d948ae7aa 100644
--- a/src/render/defaults/qdiffusemapmaterial.h
+++ b/src/render/defaults/qdiffusemapmaterial.h
@@ -66,6 +66,7 @@ public:
     QAbstractTextureProvider *diffuse() const;
     float textureScale() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &color);
     void setSpecular(const QColor &specular);
     void setShininess(float shininess);
@@ -73,11 +74,11 @@ public:
     void setTextureScale(float textureScale);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void specularChanged();
-    void shininessChanged();
-    void textureScaleChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(QAbstractTextureProvider *diffuse);
+    void specularChanged(const QColor &specular);
+    void shininessChanged(float shininess);
+    void textureScaleChanged(float textureScale);
 
 private:
     Q_DECLARE_PRIVATE(QDiffuseMapMaterial)
diff --git a/src/render/defaults/qdiffusemapmaterial_p.h b/src/render/defaults/qdiffusemapmaterial_p.h
index 667b53ae6..cd3473fac 100644
--- a/src/render/defaults/qdiffusemapmaterial_p.h
+++ b/src/render/defaults/qdiffusemapmaterial_p.h
@@ -70,6 +70,12 @@ class QDiffuseMapMaterialPrivate : public QMaterialPrivate
 
     void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+    void handleTextureScaleChanged(const QVariant &var);
+
     QEffect *m_diffuseMapEffect;
     QAbstractTextureProvider *m_diffuseTexture;
     QParameter *m_ambientParameter;
diff --git a/src/render/defaults/qdiffusespecularmapmaterial.cpp b/src/render/defaults/qdiffusespecularmapmaterial.cpp
index 392824135..21f68ea98 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial.cpp
+++ b/src/render/defaults/qdiffusespecularmapmaterial.cpp
@@ -91,6 +91,17 @@ QDiffuseSpecularMapMaterialPrivate::QDiffuseSpecularMapMaterialPrivate()
 
 void QDiffuseSpecularMapMaterialPrivate::init()
 {
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseSpecularMapMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseSpecularMapMaterialPrivate::handleDiffuseChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseSpecularMapMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseSpecularMapMaterialPrivate::handleShininessChanged);
+    connect(m_textureScaleParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged);
+
     m_diffuseSpecularMapGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusemap.vert"))));
     m_diffuseSpecularMapGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/diffusespecularmap.frag"))));
     m_diffuseSpecularMapGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/diffusemap.vert"))));
@@ -132,6 +143,36 @@ void QDiffuseSpecularMapMaterialPrivate::init()
     q_func()->setEffect(m_diffuseSpecularMapEffect);
 }
 
+void QDiffuseSpecularMapMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseSpecularMapMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QDiffuseSpecularMapMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseSpecularMapMaterial);
+    emit q->diffuseChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QDiffuseSpecularMapMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseSpecularMapMaterial);
+    emit q->specularChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QDiffuseSpecularMapMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseSpecularMapMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
+void QDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged(const QVariant &var)
+{
+    Q_Q(QDiffuseSpecularMapMaterial);
+    emit q->textureScaleChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QDiffuseSpecularMapMaterial
     \brief The QDiffuseSpecularMapMaterial provides a default implementation of the phong lighting and bump effect where the diffuse and specular light components
@@ -160,11 +201,6 @@ QDiffuseSpecularMapMaterial::QDiffuseSpecularMapMaterial(QNode *parent)
     : QMaterial(*new QDiffuseSpecularMapMaterialPrivate, parent)
 {
     Q_D(QDiffuseSpecularMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
diff --git a/src/render/defaults/qdiffusespecularmapmaterial.h b/src/render/defaults/qdiffusespecularmapmaterial.h
index 51544babf..12b8c6fbf 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial.h
+++ b/src/render/defaults/qdiffusespecularmapmaterial.h
@@ -66,6 +66,7 @@ public:
     float shininess() const;
     float textureScale() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &ambient);
     void setDiffuse(QAbstractTextureProvider *diffuse);
     void setSpecular(QAbstractTextureProvider *specular);
@@ -73,11 +74,11 @@ public:
     void setTextureScale(float textureScale);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void specularChanged();
-    void shininessChanged();
-    void textureScaleChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(QAbstractTextureProvider *diffuse);
+    void specularChanged(QAbstractTextureProvider *specular);
+    void shininessChanged(float shininess);
+    void textureScaleChanged(float textureScale);
 
 private:
     Q_DECLARE_PRIVATE(QDiffuseSpecularMapMaterial)
diff --git a/src/render/defaults/qdiffusespecularmapmaterial_p.h b/src/render/defaults/qdiffusespecularmapmaterial_p.h
index c3fbbe44e..b6fb01a91 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial_p.h
+++ b/src/render/defaults/qdiffusespecularmapmaterial_p.h
@@ -71,6 +71,12 @@ public:
 
     void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+    void handleTextureScaleChanged(const QVariant &var);
+
     QEffect *m_diffuseSpecularMapEffect;
     QAbstractTextureProvider *m_diffuseTexture;
     QAbstractTextureProvider *m_specularTexture;
diff --git a/src/render/defaults/qforwardrenderer.cpp b/src/render/defaults/qforwardrenderer.cpp
index cd766b923..0a44381ae 100644
--- a/src/render/defaults/qforwardrenderer.cpp
+++ b/src/render/defaults/qforwardrenderer.cpp
@@ -104,9 +104,9 @@ QForwardRenderer::QForwardRenderer(QNode *parent)
     : QTechniqueFilter(*new QForwardRendererPrivate, parent)
 {
     Q_D(QForwardRenderer);
-    QObject::connect(d->m_viewport, SIGNAL(clearColorChanged()), this, SIGNAL(clearColorChanged()));
-    QObject::connect(d->m_viewport, SIGNAL(rectChanged()), this, SIGNAL(viewportRectChanged()));
-    QObject::connect(d->m_cameraSelector, SIGNAL(cameraChanged()), this, SIGNAL(cameraChanged()));
+    QObject::connect(d->m_viewport, SIGNAL(clearColorChanged(const QColor &)), this, SIGNAL(clearColorChanged(const QColor &)));
+    QObject::connect(d->m_viewport, SIGNAL(rectChanged(const QRectF &)), this, SIGNAL(viewportRectChanged(const QRectF &)));
+    QObject::connect(d->m_cameraSelector, SIGNAL(cameraChanged(Qt3DCore::QEntity *)), this, SIGNAL(cameraChanged(Qt3DCore::QEntity *)));
     d->init();
 }
 
diff --git a/src/render/defaults/qforwardrenderer.h b/src/render/defaults/qforwardrenderer.h
index 10aacde9c..44f74983c 100644
--- a/src/render/defaults/qforwardrenderer.h
+++ b/src/render/defaults/qforwardrenderer.h
@@ -57,18 +57,19 @@ public:
     explicit QForwardRenderer(Qt3DCore::QNode *parent = 0);
     ~QForwardRenderer();
 
-    void setViewportRect(const QRectF &viewportRect);
-    void setClearColor(const QColor &clearColor);
-    void setCamera(Qt3DCore::QEntity *camera);
-
     QRectF viewportRect() const;
     QColor clearColor() const;
     Qt3DCore::QEntity *camera() const;
 
+public Q_SLOTS:
+    void setViewportRect(const QRectF &viewportRect);
+    void setClearColor(const QColor &clearColor);
+    void setCamera(Qt3DCore::QEntity *camera);
+
 Q_SIGNALS:
-    void viewportRectChanged();
-    void clearColorChanged();
-    void cameraChanged();
+    void viewportRectChanged(const QRectF &viewportRect);
+    void clearColorChanged(const QColor &clearColor);
+    void cameraChanged(Qt3DCore::QEntity *camera);
 
 private:
     Q_DECLARE_PRIVATE(QForwardRenderer)
diff --git a/src/render/defaults/qgoochmaterial.cpp b/src/render/defaults/qgoochmaterial.cpp
index d35bbb68d..81d76bdbb 100644
--- a/src/render/defaults/qgoochmaterial.cpp
+++ b/src/render/defaults/qgoochmaterial.cpp
@@ -77,13 +77,21 @@ QGoochMaterialPrivate::QGoochMaterialPrivate()
 void QGoochMaterialPrivate::init()
 {
     Q_Q(QGoochMaterial);
-    QObject::connect(m_diffuseParameter, SIGNAL(valueChanged()), q, SIGNAL(diffuseChanged()));
-    QObject::connect(m_specularParameter, SIGNAL(valueChanged()), q, SIGNAL(specularChanged()));
-    QObject::connect(m_coolParameter, SIGNAL(valueChanged()), q, SIGNAL(coolChanged()));
-    QObject::connect(m_warmParameter, SIGNAL(valueChanged()), q, SIGNAL(warmChanged()));
-    QObject::connect(m_alphaParameter, SIGNAL(valueChanged()), q, SIGNAL(alphaChanged()));
-    QObject::connect(m_betaParameter, SIGNAL(valueChanged()), q, SIGNAL(betaChanged()));
-    QObject::connect(m_shininessParameter, SIGNAL(valueChanged()), q, SIGNAL(shininessChanged()));
+
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleDiffuseChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleSpecularChanged);
+    connect(m_coolParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleCoolChanged);
+    connect(m_warmParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleWarmChanged);
+    connect(m_alphaParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleAlphaChanged);
+    connect(m_betaParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleBetaChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QGoochMaterialPrivate::handleShininessChanged);
 
     m_gl3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/gooch.vert"))));
     m_gl3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/gooch.frag"))));
@@ -128,6 +136,48 @@ void QGoochMaterialPrivate::init()
     q->setEffect(m_effect);
 }
 
+void QGoochMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->diffuseChanged(var.value<QColor>());
+}
+
+void QGoochMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->specularChanged(var.value<QColor>());
+}
+
+void QGoochMaterialPrivate::handleCoolChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->coolChanged(var.value<QColor>());
+}
+
+void QGoochMaterialPrivate::handleWarmChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->warmChanged(var.value<QColor>());
+}
+
+void QGoochMaterialPrivate::handleAlphaChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->alphaChanged(var.toFloat());
+}
+
+void QGoochMaterialPrivate::handleBetaChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->betaChanged(var.toFloat());
+}
+
+void QGoochMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QGoochMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QGoochMaterial
     \brief The QGoochMaterial provides a material that implements the Gooch
diff --git a/src/render/defaults/qgoochmaterial.h b/src/render/defaults/qgoochmaterial.h
index b2dd237cf..c7eba355d 100644
--- a/src/render/defaults/qgoochmaterial.h
+++ b/src/render/defaults/qgoochmaterial.h
@@ -77,13 +77,13 @@ public Q_SLOTS:
     void setShininess(float shininess);
 
 Q_SIGNALS:
-    void diffuseChanged();
-    void specularChanged();
-    void coolChanged();
-    void warmChanged();
-    void alphaChanged();
-    void betaChanged();
-    void shininessChanged();
+    void diffuseChanged(const QColor &diffuse);
+    void specularChanged(const QColor &specular);
+    void coolChanged(const QColor &cool);
+    void warmChanged(const QColor &warm);
+    void alphaChanged(float alpha);
+    void betaChanged(float beta);
+    void shininessChanged(float shininess);
 
 protected:
     QGoochMaterial(QGoochMaterialPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/defaults/qgoochmaterial_p.h b/src/render/defaults/qgoochmaterial_p.h
index 628fc7786..5d1c56280 100644
--- a/src/render/defaults/qgoochmaterial_p.h
+++ b/src/render/defaults/qgoochmaterial_p.h
@@ -63,8 +63,17 @@ class QGoochMaterialPrivate : public QMaterialPrivate
 {
 public:
     QGoochMaterialPrivate();
+
     void init();
 
+    void handleDiffuseChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleCoolChanged(const QVariant &var);
+    void handleWarmChanged(const QVariant &var);
+    void handleAlphaChanged(const QVariant &var);
+    void handleBetaChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+
     QEffect *m_effect;
     QParameter *m_diffuseParameter;
     QParameter *m_specularParameter;
diff --git a/src/render/defaults/qnormaldiffusemapmaterial.cpp b/src/render/defaults/qnormaldiffusemapmaterial.cpp
index e038b2c81..5a72278f7 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial.cpp
+++ b/src/render/defaults/qnormaldiffusemapmaterial.cpp
@@ -91,6 +91,19 @@ QNormalDiffuseMapMaterialPrivate::QNormalDiffuseMapMaterialPrivate()
 
 void QNormalDiffuseMapMaterialPrivate::init()
 {
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleDiffuseChanged);
+    connect(m_normalParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleNormalChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleShininessChanged);
+    connect(m_textureScaleParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseMapMaterialPrivate::handleTextureScaleChanged);
+
     m_normalDiffuseGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusemap.vert"))));
     m_normalDiffuseGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusemap.frag"))));
     m_normalDiffuseGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/normaldiffusemap.vert"))));
@@ -133,6 +146,42 @@ void QNormalDiffuseMapMaterialPrivate::init()
     q_func()->setEffect(m_normalDiffuseEffect);
 }
 
+void QNormalDiffuseMapMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QNormalDiffuseMapMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->diffuseChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QNormalDiffuseMapMaterialPrivate::handleNormalChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->normalChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QNormalDiffuseMapMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->specularChanged(var.value<QColor>());
+}
+
+void QNormalDiffuseMapMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
+void QNormalDiffuseMapMaterialPrivate::handleTextureScaleChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseMapMaterial);
+    emit q->textureScaleChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QNormalDiffuseMapMaterial
     \brief The QNormalDiffuseMapMaterial provides a default implementation of the phong lighting and bump effect where the diffuse light component
@@ -161,12 +210,6 @@ QNormalDiffuseMapMaterial::QNormalDiffuseMapMaterial(QNode *parent)
     : QMaterial(*new QNormalDiffuseMapMaterialPrivate, parent)
 {
     Q_D(QNormalDiffuseMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_normalParameter, SIGNAL(valueChanged()), this, SIGNAL(normalChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
@@ -175,12 +218,6 @@ QNormalDiffuseMapMaterial::QNormalDiffuseMapMaterial(QNormalDiffuseMapMaterialPr
     : QMaterial(dd, parent)
 {
     Q_D(QNormalDiffuseMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_normalParameter, SIGNAL(valueChanged()), this, SIGNAL(normalChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
diff --git a/src/render/defaults/qnormaldiffusemapmaterial.h b/src/render/defaults/qnormaldiffusemapmaterial.h
index f6faad788..945eaa616 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial.h
+++ b/src/render/defaults/qnormaldiffusemapmaterial.h
@@ -68,6 +68,7 @@ public:
     float shininess() const;
     float textureScale() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &ambient);
     void setSpecular(const QColor &specular);
     void setDiffuse(QAbstractTextureProvider *diffuse);
@@ -76,12 +77,12 @@ public:
     void setTextureScale(float textureScale);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void normalChanged();
-    void specularChanged();
-    void shininessChanged();
-    void textureScaleChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(QAbstractTextureProvider *diffuse);
+    void normalChanged(QAbstractTextureProvider *normal);
+    void specularChanged(const QColor &specular);
+    void shininessChanged(float shininess);
+    void textureScaleChanged(float textureScale);
 
 protected:
     QNormalDiffuseMapMaterial(QNormalDiffuseMapMaterialPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/defaults/qnormaldiffusemapmaterial_p.h b/src/render/defaults/qnormaldiffusemapmaterial_p.h
index 996aa76c9..ba28d971f 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial_p.h
+++ b/src/render/defaults/qnormaldiffusemapmaterial_p.h
@@ -71,6 +71,13 @@ public:
 
     virtual void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleNormalChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+    void handleTextureScaleChanged(const QVariant &var);
+
     QEffect *m_normalDiffuseEffect;
     QAbstractTextureProvider *m_diffuseTexture;
     QAbstractTextureProvider *m_normalTexture;
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp b/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
index 05adf12ca..6a359a1e2 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
@@ -97,6 +97,19 @@ QNormalDiffuseSpecularMapMaterialPrivate::QNormalDiffuseSpecularMapMaterialPriva
 
 void QNormalDiffuseSpecularMapMaterialPrivate::init()
 {
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleDiffuseChanged);
+    connect(m_normalParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleNormalChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleShininessChanged);
+    connect(m_textureScaleParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QNormalDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged);
+
     m_normalDiffuseSpecularGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusemap.vert"))));
     m_normalDiffuseSpecularGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/normaldiffusespecularmap.frag"))));
     m_normalDiffuseSpecularGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/normaldiffusemap.vert"))));
@@ -139,6 +152,42 @@ void QNormalDiffuseSpecularMapMaterialPrivate::init()
     q_func()->setEffect(m_normalDiffuseSpecularEffect);
 }
 
+void QNormalDiffuseSpecularMapMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QNormalDiffuseSpecularMapMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->diffuseChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QNormalDiffuseSpecularMapMaterialPrivate::handleNormalChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->normalChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QNormalDiffuseSpecularMapMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->specularChanged(var.value<QAbstractTextureProvider *>());
+}
+
+void QNormalDiffuseSpecularMapMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
+void QNormalDiffuseSpecularMapMaterialPrivate::handleTextureScaleChanged(const QVariant &var)
+{
+    Q_Q(QNormalDiffuseSpecularMapMaterial);
+    emit q->textureScaleChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QNormalDiffuseSpecularMapMaterial
     \brief The QNormalDiffuseSpecularMapMaterial provides a default implementation of the phong lighting and bump effect where the diffuse and specular light components
@@ -167,12 +216,6 @@ QNormalDiffuseSpecularMapMaterial::QNormalDiffuseSpecularMapMaterial(QNode *pare
     : QMaterial(*new QNormalDiffuseSpecularMapMaterialPrivate, parent)
 {
     Q_D(QNormalDiffuseSpecularMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_normalParameter, SIGNAL(valueChanged()), this, SIGNAL(normalChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
@@ -181,12 +224,6 @@ QNormalDiffuseSpecularMapMaterial::QNormalDiffuseSpecularMapMaterial(QNormalDiff
     : QMaterial(dd, parent)
 {
     Q_D(QNormalDiffuseSpecularMapMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_normalParameter, SIGNAL(valueChanged()), this, SIGNAL(normalChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_textureScaleParameter, SIGNAL(valueChanged()), this, SIGNAL(textureScaleChanged()));
     d->init();
 }
 
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial.h b/src/render/defaults/qnormaldiffusespecularmapmaterial.h
index 6f437288d..502656aef 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial.h
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial.h
@@ -67,6 +67,7 @@ public:
     float shininess() const;
     float textureScale() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &ambient);
     void setDiffuse(QAbstractTextureProvider *diffuse);
     void setNormal(QAbstractTextureProvider *normal);
@@ -75,12 +76,12 @@ public:
     void setTextureScale(float textureScale);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void normalChanged();
-    void specularChanged();
-    void shininessChanged();
-    void textureScaleChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(QAbstractTextureProvider *diffuse);
+    void normalChanged(QAbstractTextureProvider *normal);
+    void specularChanged(QAbstractTextureProvider *specular);
+    void shininessChanged(float shininess);
+    void textureScaleChanged(float textureScale);
 
 protected:
     QNormalDiffuseSpecularMapMaterial(QNormalDiffuseSpecularMapMaterialPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h b/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
index 672dc19b3..f3283f85e 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
@@ -71,6 +71,13 @@ public:
 
     void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleNormalChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+    void handleTextureScaleChanged(const QVariant &var);
+
     QEffect *m_normalDiffuseSpecularEffect;
     QAbstractTextureProvider *m_diffuseTexture;
     QAbstractTextureProvider *m_normalTexture;
diff --git a/src/render/defaults/qphongalphamaterial.cpp b/src/render/defaults/qphongalphamaterial.cpp
index 321469404..c9045461f 100644
--- a/src/render/defaults/qphongalphamaterial.cpp
+++ b/src/render/defaults/qphongalphamaterial.cpp
@@ -80,6 +80,108 @@ QPhongAlphaMaterialPrivate::QPhongAlphaMaterialPrivate()
 {
 }
 
+// TODO: Define how lights are properties are set in the shaders. Ideally using a QShaderData
+void QPhongAlphaMaterialPrivate::init()
+{
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongAlphaMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongAlphaMaterialPrivate::handleDiffuseChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongAlphaMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongAlphaMaterialPrivate::handleShininessChanged);
+    connect(m_alphaParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongAlphaMaterialPrivate::handleAlphaChanged);
+
+    m_phongAlphaGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phongalpha.vert"))));
+    m_phongAlphaGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phongalpha.frag"))));
+    m_phongAlphaGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phongalpha.vert"))));
+    m_phongAlphaGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phongalpha.frag"))));
+
+    m_phongAlphaGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
+    m_phongAlphaGL3Technique->graphicsApiFilter()->setMajorVersion(3);
+    m_phongAlphaGL3Technique->graphicsApiFilter()->setMinorVersion(1);
+    m_phongAlphaGL3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
+
+    m_phongAlphaGL2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
+    m_phongAlphaGL2Technique->graphicsApiFilter()->setMajorVersion(2);
+    m_phongAlphaGL2Technique->graphicsApiFilter()->setMinorVersion(0);
+    m_phongAlphaGL2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
+
+    m_phongAlphaES2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
+    m_phongAlphaES2Technique->graphicsApiFilter()->setMajorVersion(2);
+    m_phongAlphaES2Technique->graphicsApiFilter()->setMinorVersion(0);
+    m_phongAlphaES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
+
+    m_depthMask->setMask(false);
+    m_blendState->setSrcRGB(QBlendState::SrcAlpha);
+    m_blendState->setDstRGB(QBlendState::OneMinusSrcAlpha);
+    m_blendEquation->setMode(QBlendEquation::FuncAdd);
+
+    m_phongAlphaGL3RenderPass->setShaderProgram(m_phongAlphaGL3Shader);
+    m_phongAlphaGL2RenderPass->setShaderProgram(m_phongAlphaGL2ES2Shader);
+    m_phongAlphaES2RenderPass->setShaderProgram(m_phongAlphaGL2ES2Shader);
+
+    m_phongAlphaGL3RenderPass->addRenderState(m_depthMask);
+    m_phongAlphaGL3RenderPass->addRenderState(m_blendState);
+    m_phongAlphaGL3RenderPass->addRenderState(m_blendEquation);
+
+    m_phongAlphaGL2RenderPass->addRenderState(m_depthMask);
+    m_phongAlphaGL2RenderPass->addRenderState(m_blendState);
+    m_phongAlphaGL2RenderPass->addRenderState(m_blendEquation);
+
+    m_phongAlphaES2RenderPass->addRenderState(m_depthMask);
+    m_phongAlphaES2RenderPass->addRenderState(m_blendState);
+    m_phongAlphaES2RenderPass->addRenderState(m_blendEquation);
+
+    m_phongAlphaGL3Technique->addPass(m_phongAlphaGL3RenderPass);
+    m_phongAlphaGL2Technique->addPass(m_phongAlphaGL2RenderPass);
+    m_phongAlphaES2Technique->addPass(m_phongAlphaES2RenderPass);
+
+    m_phongEffect->addTechnique(m_phongAlphaGL3Technique);
+    m_phongEffect->addTechnique(m_phongAlphaGL2Technique);
+    m_phongEffect->addTechnique(m_phongAlphaES2Technique);
+
+    m_phongEffect->addParameter(m_ambientParameter);
+    m_phongEffect->addParameter(m_diffuseParameter);
+    m_phongEffect->addParameter(m_specularParameter);
+    m_phongEffect->addParameter(m_shininessParameter);
+    m_phongEffect->addParameter(m_alphaParameter);
+
+    q_func()->setEffect(m_phongEffect);
+}
+
+void QPhongAlphaMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QPhongAlphaMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QPhongAlphaMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QPhongAlphaMaterial);
+    emit q->diffuseChanged(var.value<QColor>());
+}
+
+void QPhongAlphaMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QPhongAlphaMaterial);
+    emit q->specularChanged(var.value<QColor>());
+}
+
+void QPhongAlphaMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QPhongAlphaMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
+void QPhongAlphaMaterialPrivate::handleAlphaChanged(const QVariant &var)
+{
+    Q_Q(QPhongAlphaMaterial);
+    emit q->alphaChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QPhongAlphaMaterial
 
@@ -113,11 +215,6 @@ QPhongAlphaMaterial::QPhongAlphaMaterial(QNode *parent)
     : QMaterial(*new QPhongAlphaMaterialPrivate, parent)
 {
     Q_D(QPhongAlphaMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
-    QObject::connect(d->m_alphaParameter, SIGNAL(valueChanged()), this, SIGNAL(alphaChanged()));
     d->init();
 }
 
@@ -217,67 +314,6 @@ void QPhongAlphaMaterial::setAlpha(float alpha)
     d->m_alphaParameter->setValue(alpha);
 }
 
-// TODO: Define how lights are properties are set in the shaders. Ideally using a QShaderData
-void QPhongAlphaMaterialPrivate::init()
-{
-    m_phongAlphaGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phongalpha.vert"))));
-    m_phongAlphaGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phongalpha.frag"))));
-    m_phongAlphaGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phongalpha.vert"))));
-    m_phongAlphaGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phongalpha.frag"))));
-
-    m_phongAlphaGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
-    m_phongAlphaGL3Technique->graphicsApiFilter()->setMajorVersion(3);
-    m_phongAlphaGL3Technique->graphicsApiFilter()->setMinorVersion(1);
-    m_phongAlphaGL3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
-
-    m_phongAlphaGL2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
-    m_phongAlphaGL2Technique->graphicsApiFilter()->setMajorVersion(2);
-    m_phongAlphaGL2Technique->graphicsApiFilter()->setMinorVersion(0);
-    m_phongAlphaGL2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
-
-    m_phongAlphaES2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
-    m_phongAlphaES2Technique->graphicsApiFilter()->setMajorVersion(2);
-    m_phongAlphaES2Technique->graphicsApiFilter()->setMinorVersion(0);
-    m_phongAlphaES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
-
-    m_depthMask->setMask(false);
-    m_blendState->setSrcRGB(QBlendState::SrcAlpha);
-    m_blendState->setDstRGB(QBlendState::OneMinusSrcAlpha);
-    m_blendEquation->setMode(QBlendEquation::FuncAdd);
-
-    m_phongAlphaGL3RenderPass->setShaderProgram(m_phongAlphaGL3Shader);
-    m_phongAlphaGL2RenderPass->setShaderProgram(m_phongAlphaGL2ES2Shader);
-    m_phongAlphaES2RenderPass->setShaderProgram(m_phongAlphaGL2ES2Shader);
-
-    m_phongAlphaGL3RenderPass->addRenderState(m_depthMask);
-    m_phongAlphaGL3RenderPass->addRenderState(m_blendState);
-    m_phongAlphaGL3RenderPass->addRenderState(m_blendEquation);
-
-    m_phongAlphaGL2RenderPass->addRenderState(m_depthMask);
-    m_phongAlphaGL2RenderPass->addRenderState(m_blendState);
-    m_phongAlphaGL2RenderPass->addRenderState(m_blendEquation);
-
-    m_phongAlphaES2RenderPass->addRenderState(m_depthMask);
-    m_phongAlphaES2RenderPass->addRenderState(m_blendState);
-    m_phongAlphaES2RenderPass->addRenderState(m_blendEquation);
-
-    m_phongAlphaGL3Technique->addPass(m_phongAlphaGL3RenderPass);
-    m_phongAlphaGL2Technique->addPass(m_phongAlphaGL2RenderPass);
-    m_phongAlphaES2Technique->addPass(m_phongAlphaES2RenderPass);
-
-    m_phongEffect->addTechnique(m_phongAlphaGL3Technique);
-    m_phongEffect->addTechnique(m_phongAlphaGL2Technique);
-    m_phongEffect->addTechnique(m_phongAlphaES2Technique);
-
-    m_phongEffect->addParameter(m_ambientParameter);
-    m_phongEffect->addParameter(m_diffuseParameter);
-    m_phongEffect->addParameter(m_specularParameter);
-    m_phongEffect->addParameter(m_shininessParameter);
-    m_phongEffect->addParameter(m_alphaParameter);
-
-    q_func()->setEffect(m_phongEffect);
-}
-
 } // namespace Qt3DRender
 
 QT_END_NAMESPACE
diff --git a/src/render/defaults/qphongalphamaterial.h b/src/render/defaults/qphongalphamaterial.h
index 7d4d88ffc..556777184 100644
--- a/src/render/defaults/qphongalphamaterial.h
+++ b/src/render/defaults/qphongalphamaterial.h
@@ -65,6 +65,7 @@ public:
     float shininess() const;
     float alpha() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &ambient);
     void setDiffuse(const QColor &diffuse);
     void setSpecular(const QColor &specular);
@@ -72,11 +73,11 @@ public:
     void setAlpha(float alpha);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void specularChanged();
-    void shininessChanged();
-    void alphaChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(const QColor &diffuse);
+    void specularChanged(const QColor &specular);
+    void shininessChanged(float shininess);
+    void alphaChanged(float alpha);
 
 private:
     Q_DECLARE_PRIVATE(QPhongAlphaMaterial)
diff --git a/src/render/defaults/qphongalphamaterial_p.h b/src/render/defaults/qphongalphamaterial_p.h
index b2598ced6..10c9092b1 100644
--- a/src/render/defaults/qphongalphamaterial_p.h
+++ b/src/render/defaults/qphongalphamaterial_p.h
@@ -73,6 +73,12 @@ public:
 
     void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+    void handleAlphaChanged(const QVariant &var);
+
     QEffect *m_phongEffect;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
diff --git a/src/render/defaults/qphongmaterial.cpp b/src/render/defaults/qphongmaterial.cpp
index 7d18afccc..233eebd6e 100644
--- a/src/render/defaults/qphongmaterial.cpp
+++ b/src/render/defaults/qphongmaterial.cpp
@@ -73,6 +73,82 @@ QPhongMaterialPrivate::QPhongMaterialPrivate()
 {
 }
 
+// TODO: Define how lights are properties are set in the shaders. Ideally using a QShaderData
+void QPhongMaterialPrivate::init()
+{
+    connect(m_ambientParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongMaterialPrivate::handleAmbientChanged);
+    connect(m_diffuseParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongMaterialPrivate::handleDiffuseChanged);
+    connect(m_specularParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongMaterialPrivate::handleSpecularChanged);
+    connect(m_shininessParameter, &Qt3DRender::QParameter::valueChanged,
+            this, &QPhongMaterialPrivate::handleShininessChanged);
+
+    m_phongGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.vert"))));
+    m_phongGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.frag"))));
+    m_phongGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.vert"))));
+    m_phongGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.frag"))));
+
+    m_phongGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
+    m_phongGL3Technique->graphicsApiFilter()->setMajorVersion(3);
+    m_phongGL3Technique->graphicsApiFilter()->setMinorVersion(1);
+    m_phongGL3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
+
+    m_phongGL2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
+    m_phongGL2Technique->graphicsApiFilter()->setMajorVersion(2);
+    m_phongGL2Technique->graphicsApiFilter()->setMinorVersion(0);
+    m_phongGL2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
+
+    m_phongES2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
+    m_phongES2Technique->graphicsApiFilter()->setMajorVersion(2);
+    m_phongES2Technique->graphicsApiFilter()->setMinorVersion(0);
+    m_phongES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
+
+    m_phongGL3RenderPass->setShaderProgram(m_phongGL3Shader);
+    m_phongGL2RenderPass->setShaderProgram(m_phongGL2ES2Shader);
+    m_phongES2RenderPass->setShaderProgram(m_phongGL2ES2Shader);
+
+    m_phongGL3Technique->addPass(m_phongGL3RenderPass);
+    m_phongGL2Technique->addPass(m_phongGL2RenderPass);
+    m_phongES2Technique->addPass(m_phongES2RenderPass);
+
+    m_phongEffect->addTechnique(m_phongGL3Technique);
+    m_phongEffect->addTechnique(m_phongGL2Technique);
+    m_phongEffect->addTechnique(m_phongES2Technique);
+
+    m_phongEffect->addParameter(m_ambientParameter);
+    m_phongEffect->addParameter(m_diffuseParameter);
+    m_phongEffect->addParameter(m_specularParameter);
+    m_phongEffect->addParameter(m_shininessParameter);
+
+    q_func()->setEffect(m_phongEffect);
+}
+
+void QPhongMaterialPrivate::handleAmbientChanged(const QVariant &var)
+{
+    Q_Q(QPhongMaterial);
+    emit q->ambientChanged(var.value<QColor>());
+}
+
+void QPhongMaterialPrivate::handleDiffuseChanged(const QVariant &var)
+{
+    Q_Q(QPhongMaterial);
+    emit q->diffuseChanged(var.value<QColor>());
+}
+
+void QPhongMaterialPrivate::handleSpecularChanged(const QVariant &var)
+{
+    Q_Q(QPhongMaterial);
+    emit q->specularChanged(var.value<QColor>());
+}
+
+void QPhongMaterialPrivate::handleShininessChanged(const QVariant &var)
+{
+    Q_Q(QPhongMaterial);
+    emit q->shininessChanged(var.toFloat());
+}
+
 /*!
     \class Qt3DRender::QPhongMaterial
     \brief The QPhongMaterial class provides a default implementation of the phong lighting effect.
@@ -102,10 +178,6 @@ QPhongMaterial::QPhongMaterial(QNode *parent)
     : QMaterial(*new QPhongMaterialPrivate, parent)
 {
     Q_D(QPhongMaterial);
-    QObject::connect(d->m_ambientParameter, SIGNAL(valueChanged()), this, SIGNAL(ambientChanged()));
-    QObject::connect(d->m_diffuseParameter, SIGNAL(valueChanged()), this, SIGNAL(diffuseChanged()));
-    QObject::connect(d->m_specularParameter, SIGNAL(valueChanged()), this, SIGNAL(specularChanged()));
-    QObject::connect(d->m_shininessParameter, SIGNAL(valueChanged()), this, SIGNAL(shininessChanged()));
     d->init();
 }
 
@@ -186,49 +258,6 @@ void QPhongMaterial::setShininess(float shininess)
     d->m_shininessParameter->setValue(shininess);
 }
 
-// TODO: Define how lights are properties are set in the shaders. Ideally using a QShaderData
-void QPhongMaterialPrivate::init()
-{
-    m_phongGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.vert"))));
-    m_phongGL3Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/gl3/phong.frag"))));
-    m_phongGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.vert"))));
-    m_phongGL2ES2Shader->setFragmentShaderCode(QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/shaders/es2/phong.frag"))));
-
-    m_phongGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
-    m_phongGL3Technique->graphicsApiFilter()->setMajorVersion(3);
-    m_phongGL3Technique->graphicsApiFilter()->setMinorVersion(1);
-    m_phongGL3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
-
-    m_phongGL2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
-    m_phongGL2Technique->graphicsApiFilter()->setMajorVersion(2);
-    m_phongGL2Technique->graphicsApiFilter()->setMinorVersion(0);
-    m_phongGL2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
-
-    m_phongES2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
-    m_phongES2Technique->graphicsApiFilter()->setMajorVersion(2);
-    m_phongES2Technique->graphicsApiFilter()->setMinorVersion(0);
-    m_phongES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
-
-    m_phongGL3RenderPass->setShaderProgram(m_phongGL3Shader);
-    m_phongGL2RenderPass->setShaderProgram(m_phongGL2ES2Shader);
-    m_phongES2RenderPass->setShaderProgram(m_phongGL2ES2Shader);
-
-    m_phongGL3Technique->addPass(m_phongGL3RenderPass);
-    m_phongGL2Technique->addPass(m_phongGL2RenderPass);
-    m_phongES2Technique->addPass(m_phongES2RenderPass);
-
-    m_phongEffect->addTechnique(m_phongGL3Technique);
-    m_phongEffect->addTechnique(m_phongGL2Technique);
-    m_phongEffect->addTechnique(m_phongES2Technique);
-
-    m_phongEffect->addParameter(m_ambientParameter);
-    m_phongEffect->addParameter(m_diffuseParameter);
-    m_phongEffect->addParameter(m_specularParameter);
-    m_phongEffect->addParameter(m_shininessParameter);
-
-    q_func()->setEffect(m_phongEffect);
-}
-
 } // namespace Qt3DRender
 
 QT_END_NAMESPACE
diff --git a/src/render/defaults/qphongmaterial.h b/src/render/defaults/qphongmaterial.h
index ba4a42afb..d9c50d515 100644
--- a/src/render/defaults/qphongmaterial.h
+++ b/src/render/defaults/qphongmaterial.h
@@ -63,16 +63,17 @@ public:
     QColor specular() const;
     float shininess() const;
 
+public Q_SLOTS:
     void setAmbient(const QColor &ambient);
     void setDiffuse(const QColor &diffuse);
     void setSpecular(const QColor &specular);
     void setShininess(float shininess);
 
 Q_SIGNALS:
-    void ambientChanged();
-    void diffuseChanged();
-    void specularChanged();
-    void shininessChanged();
+    void ambientChanged(const QColor &ambient);
+    void diffuseChanged(const QColor &diffuse);
+    void specularChanged(const QColor &specular);
+    void shininessChanged(float shininess);
 
 private:
     Q_DECLARE_PRIVATE(QPhongMaterial)
diff --git a/src/render/defaults/qphongmaterial_p.h b/src/render/defaults/qphongmaterial_p.h
index 33ae2f048..91892af64 100644
--- a/src/render/defaults/qphongmaterial_p.h
+++ b/src/render/defaults/qphongmaterial_p.h
@@ -70,6 +70,11 @@ public:
 
     void init();
 
+    void handleAmbientChanged(const QVariant &var);
+    void handleDiffuseChanged(const QVariant &var);
+    void handleSpecularChanged(const QVariant &var);
+    void handleShininessChanged(const QVariant &var);
+
     QEffect *m_phongEffect;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
diff --git a/src/render/defaults/qskyboxentity.cpp b/src/render/defaults/qskyboxentity.cpp
index 39a68723b..df44af9bb 100644
--- a/src/render/defaults/qskyboxentity.cpp
+++ b/src/render/defaults/qskyboxentity.cpp
@@ -221,7 +221,7 @@ void QSkyboxEntity::setBaseName(const QString &baseName)
     Q_D(QSkyboxEntity);
     if (baseName != d->m_baseName) {
         d->m_baseName = baseName;
-        emit sourceDirectoryChanged();
+        emit sourceDirectoryChanged(baseName);
         d->reloadTexture();
     }
 }
@@ -242,7 +242,7 @@ void QSkyboxEntity::setExtension(const QString &extension)
     Q_D(QSkyboxEntity);
     if (extension != d->m_extension) {
         d->m_extension = extension;
-        emit extensionChanged();
+        emit extensionChanged(extension);
         d->reloadTexture();
     }
 }
@@ -265,7 +265,7 @@ void QSkyboxEntity::setCameraPosition(const QVector3D &cameraPosition)
     if (cameraPosition != d->m_position) {
         d->m_position = cameraPosition;
         d->m_transform->setTranslation(d->m_position);
-        emit cameraPositionChanged();
+        emit cameraPositionChanged(cameraPosition);
     }
 }
 
diff --git a/src/render/defaults/qskyboxentity.h b/src/render/defaults/qskyboxentity.h
index d0406466a..4dfa84804 100644
--- a/src/render/defaults/qskyboxentity.h
+++ b/src/render/defaults/qskyboxentity.h
@@ -63,9 +63,9 @@ public:
     QVector3D cameraPosition() const;
 
 Q_SIGNALS:
-    void sourceDirectoryChanged();
-    void extensionChanged();
-    void cameraPositionChanged();
+    void sourceDirectoryChanged(const QString &path);
+    void extensionChanged(const QString &extension);
+    void cameraPositionChanged(const QVector3D &cameraPosition);
 
 private:
     Q_DECLARE_PRIVATE(QSkyboxEntity)