Added parameters to signals and made setters Q_SLOTS

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

142 files changed, 1080 insertions, 708 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)
diff --git a/src/render/framegraph/qcameraselector.cpp b/src/render/framegraph/qcameraselector.cpp
index 6515cc0d1..4a81e5858 100644
--- a/src/render/framegraph/qcameraselector.cpp
+++ b/src/render/framegraph/qcameraselector.cpp
@@ -97,7 +97,7 @@ void QCameraSelector::setCamera(Qt3DCore::QEntity *camera)
         // 2) When the current node is destroyed, it gets destroyed as well
         if (camera && !camera->parent())
             camera->setParent(this);
-        emit cameraChanged();
+        emit cameraChanged(camera);
     }
 }
 
diff --git a/src/render/framegraph/qcameraselector.h b/src/render/framegraph/qcameraselector.h
index 3a663768f..b5a14bfb5 100644
--- a/src/render/framegraph/qcameraselector.h
+++ b/src/render/framegraph/qcameraselector.h
@@ -55,11 +55,13 @@ public:
     explicit QCameraSelector(Qt3DCore::QNode *parent = 0);
     ~QCameraSelector();
 
-    void setCamera(Qt3DCore::QEntity *camera);
     Qt3DCore::QEntity *camera() const;
 
+public Q_SLOTS:
+    void setCamera(Qt3DCore::QEntity *camera);
+
 Q_SIGNALS:
-    void cameraChanged();
+    void cameraChanged(Qt3DCore::QEntity *camera);
 
 protected:
     QCameraSelector(QCameraSelectorPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qclearbuffer.cpp b/src/render/framegraph/qclearbuffer.cpp
index 5706f6aa7..c2b675538 100644
--- a/src/render/framegraph/qclearbuffer.cpp
+++ b/src/render/framegraph/qclearbuffer.cpp
@@ -87,7 +87,7 @@ void QClearBuffer::setBuffers(QClearBuffer::BufferType buffers)
     Q_D(QClearBuffer);
     if (d->m_buffersType != buffers) {
         d->m_buffersType = buffers;
-        emit buffersChanged();
+        emit buffersChanged(buffers);
     }
 }
 
diff --git a/src/render/framegraph/qclearbuffer.h b/src/render/framegraph/qclearbuffer.h
index d6adcf209..06ac480b2 100644
--- a/src/render/framegraph/qclearbuffer.h
+++ b/src/render/framegraph/qclearbuffer.h
@@ -65,11 +65,13 @@ public:
     };
     Q_ENUM(BufferType)
 
-    void setBuffers(BufferType buffers);
     BufferType buffers() const;
 
+public Q_SLOTS:
+    void setBuffers(BufferType buffers);
+
 Q_SIGNALS:
-    void buffersChanged();
+    void buffersChanged(BufferType buffers);
 
 protected:
     QClearBuffer(QClearBufferPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qframegraph.cpp b/src/render/framegraph/qframegraph.cpp
index c1a338211..8505901d1 100644
--- a/src/render/framegraph/qframegraph.cpp
+++ b/src/render/framegraph/qframegraph.cpp
@@ -138,7 +138,7 @@ void QFrameGraph::setActiveFrameGraph(QFrameGraphNode *activeFrameGraph)
             activeFrameGraph->setParent(this);
 
         d->m_activeFrameGraph = activeFrameGraph;
-        emit activeFrameGraphChanged();
+        emit activeFrameGraphChanged(activeFrameGraph);
     }
 }
 
diff --git a/src/render/framegraph/qframegraph.h b/src/render/framegraph/qframegraph.h
index 35cf09b09..3c8604eb7 100644
--- a/src/render/framegraph/qframegraph.h
+++ b/src/render/framegraph/qframegraph.h
@@ -60,10 +60,12 @@ public:
     ~QFrameGraph();
 
     QFrameGraphNode *activeFrameGraph() const;
+
+public Q_SLOTS:
     void setActiveFrameGraph(QFrameGraphNode *activeFrameGraph);
 
 Q_SIGNALS:
-    void activeFrameGraphChanged();
+    void activeFrameGraphChanged(QFrameGraphNode *activeFrameGraph);
 
 protected:
     QFrameGraph(QFrameGraphPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qframegraphnode.cpp b/src/render/framegraph/qframegraphnode.cpp
index 18d191b38..116c7a99e 100644
--- a/src/render/framegraph/qframegraphnode.cpp
+++ b/src/render/framegraph/qframegraphnode.cpp
@@ -130,7 +130,7 @@ void QFrameGraphNode::setEnabled(bool enabled)
     Q_D(QFrameGraphNode);
     if (d->m_enabled != enabled) {
         d->m_enabled = enabled;
-        emit enabledChanged();
+        emit enabledChanged(enabled);
     }
 }
 
diff --git a/src/render/framegraph/qframegraphnode.h b/src/render/framegraph/qframegraphnode.h
index cbde0be3e..851b2fd74 100644
--- a/src/render/framegraph/qframegraphnode.h
+++ b/src/render/framegraph/qframegraphnode.h
@@ -58,13 +58,15 @@ public:
     QFrameGraphNode *parentFrameGraphNode() const;
 
     bool isEnabled() const;
+
+public Q_SLOTS:
     void setEnabled(bool enabled);
 
 protected:
     QFrameGraphNode(QFrameGraphNodePrivate &dd, Qt3DCore::QNode *parent = 0);
 
 Q_SIGNALS:
-    void enabledChanged();
+    void enabledChanged(bool enabled);
 
 private:
     Q_DECLARE_PRIVATE(QFrameGraphNode)
diff --git a/src/render/framegraph/qlayerfilter.cpp b/src/render/framegraph/qlayerfilter.cpp
index 1bb3fea09..100ff975c 100644
--- a/src/render/framegraph/qlayerfilter.cpp
+++ b/src/render/framegraph/qlayerfilter.cpp
@@ -112,7 +112,7 @@ void QLayerFilter::setLayers(const QStringList &layers)
     Q_D(QLayerFilter);
     if (d->m_layers != layers) {
         d->m_layers = layers;
-        emit layersChanged();
+        emit layersChanged(layers);
     }
 }
 
diff --git a/src/render/framegraph/qlayerfilter.h b/src/render/framegraph/qlayerfilter.h
index 5ba129ba7..749acbb2b 100644
--- a/src/render/framegraph/qlayerfilter.h
+++ b/src/render/framegraph/qlayerfilter.h
@@ -54,11 +54,13 @@ public:
     explicit QLayerFilter(Qt3DCore::QNode *parent = 0);
     ~QLayerFilter();
 
-    void setLayers(const QStringList &layers);
     QStringList layers() const;
 
+public Q_SLOTS:
+    void setLayers(const QStringList &layers);
+
 Q_SIGNALS:
-    void layersChanged();
+    void layersChanged(const QStringList &layers);
 
 protected:
     QLayerFilter(QLayerFilterPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qrendertargetselector.cpp b/src/render/framegraph/qrendertargetselector.cpp
index 1cd17d911..0a673927a 100644
--- a/src/render/framegraph/qrendertargetselector.cpp
+++ b/src/render/framegraph/qrendertargetselector.cpp
@@ -86,7 +86,7 @@ void QRenderTargetSelector::setTarget(QRenderTarget *target)
         // For inline declaration cases
         if (target != Q_NULLPTR && !target->parent())
             target->setParent(this);
-        emit targetChanged();
+        emit targetChanged(target);
     }
 }
 
diff --git a/src/render/framegraph/qrendertargetselector.h b/src/render/framegraph/qrendertargetselector.h
index dc50adb97..d2fbb81b8 100644
--- a/src/render/framegraph/qrendertargetselector.h
+++ b/src/render/framegraph/qrendertargetselector.h
@@ -57,14 +57,16 @@ public:
     explicit QRenderTargetSelector(Qt3DCore::QNode *parent = 0);
     ~QRenderTargetSelector();
 
-    void setTarget(QRenderTarget *target);
     QRenderTarget *target() const;
 
     void setDrawBuffers(const QList<QRenderAttachment::RenderAttachmentType> &buffers);
     QList<QRenderAttachment::RenderAttachmentType> drawBuffers() const;
 
+public Q_SLOTS:
+    void setTarget(QRenderTarget *target);
+
 Q_SIGNALS:
-    void targetChanged();
+    void targetChanged(QRenderTarget *target);
 
 protected:
     QRenderTargetSelector(QRenderTargetSelectorPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qsortcriterion.cpp b/src/render/framegraph/qsortcriterion.cpp
index c907e2a18..4c6cec80e 100644
--- a/src/render/framegraph/qsortcriterion.cpp
+++ b/src/render/framegraph/qsortcriterion.cpp
@@ -80,7 +80,7 @@ void QSortCriterion::setSort(QSortCriterion::SortType sort)
     Q_D(QSortCriterion);
     if (d->m_sort != sort) {
         d->m_sort = sort;
-        emit sortChanged();
+        emit sortChanged(sort);
     }
 }
 
diff --git a/src/render/framegraph/qsortcriterion.h b/src/render/framegraph/qsortcriterion.h
index 72f6cd76c..e38356e66 100644
--- a/src/render/framegraph/qsortcriterion.h
+++ b/src/render/framegraph/qsortcriterion.h
@@ -62,10 +62,12 @@ public:
     Q_ENUM(SortType)
 
     SortType sort() const;
+
+public Q_SLOTS:
     void setSort(SortType sort);
 
 Q_SIGNALS:
-    void sortChanged();
+    void sortChanged(SortType sort);
 
 protected:
     QSortCriterion(QSortCriterionPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/framegraph/qviewport.cpp b/src/render/framegraph/qviewport.cpp
index 19ad2f30b..770ddeb6b 100644
--- a/src/render/framegraph/qviewport.cpp
+++ b/src/render/framegraph/qviewport.cpp
@@ -88,7 +88,7 @@ void QViewport::setRect(const QRectF &rect)
     Q_D(QViewport);
     if (rect != d->m_rect) {
         d->m_rect = rect;
-        emit rectChanged();
+        emit rectChanged(rect);
     }
 }
 
@@ -103,7 +103,7 @@ void QViewport::setClearColor(const QColor &color)
     Q_D(QViewport);
     if (color != d->m_clearColor) {
         d->m_clearColor = color;
-        emit clearColorChanged();
+        emit clearColorChanged(color);
     }
 }
 
diff --git a/src/render/framegraph/qviewport.h b/src/render/framegraph/qviewport.h
index 63750a98f..91cdae73e 100644
--- a/src/render/framegraph/qviewport.h
+++ b/src/render/framegraph/qviewport.h
@@ -58,14 +58,15 @@ public:
     ~QViewport();
 
     QRectF rect() const;
-    void setRect(const QRectF& rect);
-
     QColor clearColor() const;
+
+public Q_SLOTS:
+    void setRect(const QRectF& rect);
     void setClearColor(const QColor &color);
 
 Q_SIGNALS:
-    void rectChanged();
-    void clearColorChanged();
+    void rectChanged(const QRectF& rect);
+    void clearColorChanged(const QColor &clearColor);
 
 protected:
     QViewport(QViewportPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/frontend/qboundingvolumedebug.cpp b/src/render/frontend/qboundingvolumedebug.cpp
index 0f7482acb..e383658d4 100644
--- a/src/render/frontend/qboundingvolumedebug.cpp
+++ b/src/render/frontend/qboundingvolumedebug.cpp
@@ -96,7 +96,7 @@ void QBoundingVolumeDebug::setRecursive(bool recursive)
     Q_D(QBoundingVolumeDebug);
     if (d->m_recursive != recursive) {
         d->m_recursive = recursive;
-        emit recursiveChanged();
+        emit recursiveChanged(recursive);
     }
 }
 
diff --git a/src/render/frontend/qboundingvolumedebug.h b/src/render/frontend/qboundingvolumedebug.h
index b50d8d8ca..e6151c1ee 100644
--- a/src/render/frontend/qboundingvolumedebug.h
+++ b/src/render/frontend/qboundingvolumedebug.h
@@ -56,11 +56,13 @@ public:
     explicit QBoundingVolumeDebug(Qt3DCore::QNode *parent = Q_NULLPTR);
     ~QBoundingVolumeDebug();
 
-    void setRecursive(bool recursive);
     bool recursive() const;
 
+public Q_SLOTS:
+    void setRecursive(bool recursive);
+
 Q_SIGNALS:
-    void recursiveChanged();
+    void recursiveChanged(bool recursive);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/frontend/qlayer.cpp b/src/render/frontend/qlayer.cpp
index 107b9d250..3e049e944 100644
--- a/src/render/frontend/qlayer.cpp
+++ b/src/render/frontend/qlayer.cpp
@@ -118,7 +118,7 @@ void QLayer::setNames(const QStringList &names)
     Q_D(QLayer);
     if (d->m_names != names) {
         d->m_names = names;
-        emit namesChanged();
+        emit namesChanged(names);
     }
 }
 
diff --git a/src/render/frontend/qlayer.h b/src/render/frontend/qlayer.h
index fc3eda1b1..1d5e7bd78 100644
--- a/src/render/frontend/qlayer.h
+++ b/src/render/frontend/qlayer.h
@@ -56,10 +56,12 @@ public:
     ~QLayer();
 
     QStringList names() const;
+
+public Q_SLOTS:
     void setNames(const QStringList &names);
 
 Q_SIGNALS:
-    void namesChanged();
+    void namesChanged(const QStringList &names);
 
 protected:
     QLayer(QLayerPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/frontend/qrenderattachment.cpp b/src/render/frontend/qrenderattachment.cpp
index e0d6c42fa..d4a205fd1 100644
--- a/src/render/frontend/qrenderattachment.cpp
+++ b/src/render/frontend/qrenderattachment.cpp
@@ -85,7 +85,7 @@ void QRenderAttachment::setType(QRenderAttachment::RenderAttachmentType type)
     Q_D(QRenderAttachment);
     if (type != d->m_type) {
         d->m_type = type;
-        emit typeChanged();
+        emit typeChanged(type);
     }
 }
 
@@ -104,7 +104,7 @@ void QRenderAttachment::setTexture(QAbstractTextureProvider *texture)
         // Handle inline declaration
         if (!texture->parent())
             texture->setParent(this);
-        emit textureChanged();
+        emit textureChanged(texture);
     }
 }
 
@@ -119,7 +119,7 @@ void QRenderAttachment::setMipLevel(int level)
     Q_D(QRenderAttachment);
     if (d->m_mipLevel != level) {
         d->m_mipLevel = level;
-        emit mipLevelChanged();
+        emit mipLevelChanged(level);
     }
 }
 
@@ -134,7 +134,7 @@ void QRenderAttachment::setLayer(int layer)
     Q_D(QRenderAttachment);
     if (d->m_layer != layer) {
         d->m_layer = layer;
-        emit layerChanged();
+        emit layerChanged(layer);
     }
 }
 
@@ -149,7 +149,7 @@ void QRenderAttachment::setFace(QRenderAttachment::CubeMapFace face)
     Q_D(QRenderAttachment);
     if (d->m_face != face) {
         d->m_face = face;
-        emit faceChanged();
+        emit faceChanged(face);
     }
 }
 
@@ -164,7 +164,7 @@ void QRenderAttachment::setName(const QString &name)
     Q_D(QRenderAttachment);
     if (d->m_name != name) {
         d->m_name = name;
-        emit nameChanged();
+        emit nameChanged(name);
     }
 }
 
diff --git a/src/render/frontend/qrenderattachment.h b/src/render/frontend/qrenderattachment.h
index 89126830a..6560c08b6 100644
--- a/src/render/frontend/qrenderattachment.h
+++ b/src/render/frontend/qrenderattachment.h
@@ -94,31 +94,28 @@ public:
     explicit QRenderAttachment(Qt3DCore::QNode *parent = 0);
     ~QRenderAttachment();
 
-    void setType(RenderAttachmentType type);
     RenderAttachmentType type() const;
-
-    void setTexture(QAbstractTextureProvider *texture);
     QAbstractTextureProvider *texture() const;
-
-    void setMipLevel(int level);
     int mipLevel() const;
-
-    void setLayer(int layer);
     int layer() const;
-
-    void setFace(CubeMapFace face);
     CubeMapFace face() const;
+    QString name() const;
 
+public Q_SLOTS:
+    void setType(RenderAttachmentType type);
+    void setTexture(QAbstractTextureProvider *texture);
+    void setMipLevel(int level);
+    void setLayer(int layer);
+    void setFace(CubeMapFace face);
     void setName(const QString &name);
-    QString name() const;
 
 Q_SIGNALS:
-    void typeChanged();
-    void textureChanged();
-    void mipLevelChanged();
-    void layerChanged();
-    void faceChanged();
-    void nameChanged();
+    void typeChanged(RenderAttachmentType type);
+    void textureChanged(QAbstractTextureProvider *texture);
+    void mipLevelChanged(int mipLevel);
+    void layerChanged(int layer);
+    void faceChanged(CubeMapFace face);
+    void nameChanged(const QString &name);
 
 protected:
     QRenderAttachment(QRenderAttachmentPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/geometry/qabstractattribute.cpp b/src/render/geometry/qabstractattribute.cpp
index da3f413fd..002eed5e9 100644
--- a/src/render/geometry/qabstractattribute.cpp
+++ b/src/render/geometry/qabstractattribute.cpp
@@ -185,7 +185,7 @@ void QAbstractAttribute::setBuffer(QAbstractBuffer *buffer)
         buffer->setParent(this);
 
     d->m_buffer = buffer;
-    emit bufferChanged();
+    emit bufferChanged(buffer);
 }
 
 void QAbstractAttribute::setName(const QString &name)
@@ -195,7 +195,7 @@ void QAbstractAttribute::setName(const QString &name)
         return;
 
     d->m_name = name;
-    emit nameChanged();
+    emit nameChanged(name);
 }
 
 void QAbstractAttribute::setDataType(DataType type)
@@ -206,7 +206,7 @@ void QAbstractAttribute::setDataType(DataType type)
         return;
 
     d->m_dataType = type;
-    emit dataTypeChanged();
+    emit dataTypeChanged(type);
 }
 
 void QAbstractAttribute::setDataSize(uint size)
@@ -216,7 +216,7 @@ void QAbstractAttribute::setDataSize(uint size)
         return;
     Q_ASSERT(size >= 1 && size <= 4);
     d->m_dataSize = size;
-    emit dataSizeChanged();
+    emit dataSizeChanged(size);
 }
 
 void QAbstractAttribute::setCount(uint count)
@@ -226,7 +226,7 @@ void QAbstractAttribute::setCount(uint count)
         return;
 
     d->m_count = count;
-    emit countChanged();
+    emit countChanged(count);
 }
 
 void QAbstractAttribute::setByteStride(uint byteStride)
@@ -236,7 +236,7 @@ void QAbstractAttribute::setByteStride(uint byteStride)
         return;
 
     d->m_byteStride = byteStride;
-    emit byteStrideChanged();
+    emit byteStrideChanged(byteStride);
 }
 
 void QAbstractAttribute::setByteOffset(uint byteOffset)
@@ -246,7 +246,7 @@ void QAbstractAttribute::setByteOffset(uint byteOffset)
         return;
 
     d->m_byteOffset = byteOffset;
-    emit byteOffsetChanged();
+    emit byteOffsetChanged(byteOffset);
 }
 
 void QAbstractAttribute::setDivisor(uint divisor)
@@ -256,7 +256,7 @@ void QAbstractAttribute::setDivisor(uint divisor)
         return;
 
     d->m_divisor = divisor;
-    emit divisorChanged();
+    emit divisorChanged(divisor);
 }
 
 void QAbstractAttribute::setAttributeType(AttributeType attributeType)
@@ -266,7 +266,7 @@ void QAbstractAttribute::setAttributeType(AttributeType attributeType)
         return;
 
     d->m_attributeType = attributeType;
-    emit attributeTypeChanged();
+    emit attributeTypeChanged(attributeType);
 }
 
 } // Qt3D
diff --git a/src/render/geometry/qabstractattribute.h b/src/render/geometry/qabstractattribute.h
index 62ebdc0a5..7afc24a27 100644
--- a/src/render/geometry/qabstractattribute.h
+++ b/src/render/geometry/qabstractattribute.h
@@ -103,6 +103,7 @@ public:
     virtual QVector<QVector2D> asVector2D() const = 0;
     virtual void dump(int count) = 0;
 
+public Q_SLOTS:
     void setBuffer(QAbstractBuffer *buffer);
     void setName(const QString &name);
     void setDataType(DataType type);
@@ -114,15 +115,15 @@ public:
     void setAttributeType(AttributeType attributeType);
 
 Q_SIGNALS:
-    void bufferChanged();
-    void nameChanged();
-    void dataTypeChanged();
-    void dataSizeChanged();
-    void countChanged();
-    void byteStrideChanged();
-    void byteOffsetChanged();
-    void divisorChanged();
-    void attributeTypeChanged();
+    void bufferChanged(QAbstractBuffer *buffer);
+    void nameChanged(const QString &name);
+    void dataTypeChanged(DataType dataType);
+    void dataSizeChanged(uint dataSize);
+    void countChanged(uint count);
+    void byteStrideChanged(uint byteStride);
+    void byteOffsetChanged(uint byteOffset);
+    void divisorChanged(uint divisor);
+    void attributeTypeChanged(AttributeType attributeType);
 
 protected:
     QAbstractAttribute(QAbstractAttributePrivate &dd, QNode *parent = 0);
diff --git a/src/render/geometry/qabstractbuffer.cpp b/src/render/geometry/qabstractbuffer.cpp
index 815740aee..d0ec75451 100644
--- a/src/render/geometry/qabstractbuffer.cpp
+++ b/src/render/geometry/qabstractbuffer.cpp
@@ -80,7 +80,7 @@ void QAbstractBuffer::setData(const QByteArray &bytes)
     if (bytes != d->m_data) {
         d->m_data = bytes;
         Qt3DCore::QNodePrivate::get(this)->notifyPropertyChange("data", QVariant::fromValue(d->m_data));
-        emit dataChanged();
+        emit dataChanged(bytes);
     }
 }
 
diff --git a/src/render/geometry/qabstractbuffer.h b/src/render/geometry/qabstractbuffer.h
index 60609da99..477f96cc1 100644
--- a/src/render/geometry/qabstractbuffer.h
+++ b/src/render/geometry/qabstractbuffer.h
@@ -62,7 +62,7 @@ protected:
     void copy(const QNode *ref) Q_DECL_OVERRIDE;
 
 Q_SIGNALS:
-    void dataChanged();
+    void dataChanged(const QByteArray &bytes);
 
 private:
     Q_DECLARE_PRIVATE(QAbstractBuffer)
diff --git a/src/render/geometry/qboundingvolumespecifier.cpp b/src/render/geometry/qboundingvolumespecifier.cpp
index b1900aa12..d09c38dfd 100644
--- a/src/render/geometry/qboundingvolumespecifier.cpp
+++ b/src/render/geometry/qboundingvolumespecifier.cpp
@@ -69,7 +69,7 @@ void QBoundingVolumeSpecifier::setPositionAttribute(QAbstractAttribute *position
     Q_D(QBoundingVolumeSpecifier);
     if (positionAttribute != d->m_positionAttribute) {
         d->m_positionAttribute = positionAttribute;
-        emit positionAttributeChanged();
+        emit positionAttributeChanged(positionAttribute);
     }
 }
 
diff --git a/src/render/geometry/qboundingvolumespecifier.h b/src/render/geometry/qboundingvolumespecifier.h
index 42dc0aacb..cbc84c94f 100644
--- a/src/render/geometry/qboundingvolumespecifier.h
+++ b/src/render/geometry/qboundingvolumespecifier.h
@@ -55,10 +55,12 @@ public:
     explicit QBoundingVolumeSpecifier(QObject *parent = 0);
 
     QAbstractAttribute *positionAttribute() const;
+
+public Q_SLOTS:
     void setPositionAttribute(QAbstractAttribute *positionAttribute);
 
 Q_SIGNALS:
-    void positionAttributeChanged();
+    void positionAttributeChanged(QAbstractAttribute *positionAttribute);
 
 private:
     Q_DECLARE_PRIVATE(QBoundingVolumeSpecifier)
diff --git a/src/render/geometry/qbuffer.cpp b/src/render/geometry/qbuffer.cpp
index ad4bc6be6..276af75fe 100644
--- a/src/render/geometry/qbuffer.cpp
+++ b/src/render/geometry/qbuffer.cpp
@@ -108,7 +108,7 @@ void QBuffer::setUsage(QBuffer::UsageType usage)
     Q_D(QBuffer);
     if (usage != d->m_usage) {
         d->m_usage = usage;
-        emit usageChanged();
+        emit usageChanged(usage);
     }
 }
 
@@ -151,7 +151,7 @@ void QBuffer::setSync(bool sync)
     Q_D(QBuffer);
     if (d->m_sync != sync) {
         d->m_sync = sync;
-        emit syncChanged();
+        emit syncChanged(sync);
     }
 }
 
@@ -170,7 +170,7 @@ void QBuffer::setType(QBuffer::BufferType type)
     Q_D(QBuffer);
     if (type != d->m_type) {
         d->m_type = type;
-        emit typeChanged();
+        emit typeChanged(type);
     }
 }
 
diff --git a/src/render/geometry/qbuffer.h b/src/render/geometry/qbuffer.h
index 4c205cb95..8b91a3efd 100644
--- a/src/render/geometry/qbuffer.h
+++ b/src/render/geometry/qbuffer.h
@@ -83,17 +83,17 @@ public:
     explicit QBuffer(BufferType ty = QBuffer::VertexBuffer, Qt3DCore::QNode *parent = 0);
     ~QBuffer();
 
-    void setUsage(UsageType usage);
     UsageType usage() const;
-
-    void setType(BufferType type);
     BufferType type() const;
+    bool isSync() const;
 
     void setBufferFunctor(const QBufferFunctorPtr &functor);
     QBufferFunctorPtr bufferFunctor() const;
 
+public Q_SLOTS:
+    void setType(BufferType type);
+    void setUsage(UsageType usage);
     void setSync(bool sync);
-    bool isSync() const;
 
 protected:
     QBuffer(QBufferPrivate &dd, QBuffer::BufferType ty, Qt3DCore::QNode *parent = 0);
@@ -101,9 +101,9 @@ protected:
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) Q_DECL_OVERRIDE;
 
 Q_SIGNALS:
-    void typeChanged();
-    void usageChanged();
-    void syncChanged();
+    void typeChanged(BufferType type);
+    void usageChanged(UsageType usage);
+    void syncChanged(bool sync);
 
 private:
     Q_DECLARE_PRIVATE(QBuffer)
diff --git a/src/render/geometry/qcuboidgeometry.cpp b/src/render/geometry/qcuboidgeometry.cpp
index e8a305c69..943d2c89a 100644
--- a/src/render/geometry/qcuboidgeometry.cpp
+++ b/src/render/geometry/qcuboidgeometry.cpp
@@ -544,7 +544,7 @@ void QCuboidGeometry::setXExtent(float xExtent)
     if (d->m_xExtent != xExtent) {
         d->m_xExtent = xExtent;
         updateVertices();
-        emit xExtentChanged();
+        emit xExtentChanged(xExtent);
     }
 }
 
@@ -554,7 +554,7 @@ void QCuboidGeometry::setYExtent(float yExtent)
     if (d->m_yExtent != yExtent) {
         d->m_yExtent = yExtent;
         updateVertices();
-        emit yExtentChanged();
+        emit yExtentChanged(yExtent);
     }
 }
 
@@ -564,7 +564,7 @@ void QCuboidGeometry::setZExtent(float zExtent)
     if (d->m_zExtent != zExtent) {
         d->m_zExtent = zExtent;
         updateVertices();
-        emit zExtentChanged();
+        emit zExtentChanged(zExtent);
     }
 }
 
@@ -575,7 +575,7 @@ void QCuboidGeometry::setYZMeshResolution(const QSize &resolution)
         d->m_yzFaceResolution = resolution;
         updateVertices();
         updateIndices();
-        emit yzMeshResolutionChanged();
+        emit yzMeshResolutionChanged(resolution);
     }
 }
 
@@ -586,7 +586,7 @@ void QCuboidGeometry::setXZMeshResolution(const QSize &resolution)
         d->m_xzFaceResolution = resolution;
         updateVertices();
         updateIndices();
-        emit xzMeshResolutionChanged();
+        emit xzMeshResolutionChanged(resolution);
     }
 }
 
@@ -597,7 +597,7 @@ void QCuboidGeometry::setXYMeshResolution(const QSize &resolution)
         d->m_xyFaceResolution = resolution;
         updateVertices();
         updateIndices();
-        emit xyMeshResolutionChanged();
+        emit xyMeshResolutionChanged(resolution);
     }
 }
 
diff --git a/src/render/geometry/qcuboidgeometry.h b/src/render/geometry/qcuboidgeometry.h
index 2c9ef0c03..6118aa123 100644
--- a/src/render/geometry/qcuboidgeometry.h
+++ b/src/render/geometry/qcuboidgeometry.h
@@ -68,12 +68,6 @@ public:
 
     void updateIndices();
     void updateVertices();
-    void setXExtent(float xExtent);
-    void setYExtent(float yExtent);
-    void setZExtent(float zExtent);
-    void setYZMeshResolution(const QSize &resolution);
-    void setXZMeshResolution(const QSize &resolution);
-    void setXYMeshResolution(const QSize &resolution);
 
     float xExtent() const;
     float yExtent() const;
@@ -88,14 +82,22 @@ public:
     QAttribute *tangentAttribute() const;
     QAttribute *indexAttribute() const;
 
+public Q_SLOTS:
+    void setXExtent(float xExtent);
+    void setYExtent(float yExtent);
+    void setZExtent(float zExtent);
+    void setYZMeshResolution(const QSize &resolution);
+    void setXZMeshResolution(const QSize &resolution);
+    void setXYMeshResolution(const QSize &resolution);
+
 Q_SIGNALS:
-    void xExtentChanged();
-    void yExtentChanged();
-    void zExtentChanged();
+    void xExtentChanged(float xExtent);
+    void yExtentChanged(float yExtent);
+    void zExtentChanged(float zExtent);
 
-    void yzMeshResolutionChanged();
-    void xzMeshResolutionChanged();
-    void xyMeshResolutionChanged();
+    void yzMeshResolutionChanged(const QSize &yzMeshResolution);
+    void xzMeshResolutionChanged(const QSize &xzMeshResolution);
+    void xyMeshResolutionChanged(const QSize &xyMeshResolution);
 
 protected:
     QCuboidGeometry(QCuboidGeometryPrivate &dd, QNode *parent = Q_NULLPTR);
diff --git a/src/render/geometry/qcuboidmesh.h b/src/render/geometry/qcuboidmesh.h
index 74c9871b5..84a58a215 100644
--- a/src/render/geometry/qcuboidmesh.h
+++ b/src/render/geometry/qcuboidmesh.h
@@ -60,34 +60,29 @@ public:
     explicit QCuboidMesh(Qt3DCore::QNode *parent = 0);
     ~QCuboidMesh();
 
-    void setXExtent(float xExtent);
     float xExtent() const;
-
-    void setYExtent(float yExtent);
     float yExtent() const;
-
-    void setZExtent(float zExtent);
     float zExtent() const;
-
-    void setYZMeshResolution(const QSize &resolution);
     QSize yzMeshResolution() const;
-
-    void setXZMeshResolution(const QSize &resolution);
     QSize xzMeshResolution() const;
+    QSize xyMeshResolution() const;
 
+public Q_SLOTS:
+    void setXExtent(float xExtent);
+    void setYExtent(float yExtent);
+    void setZExtent(float zExtent);
+    void setYZMeshResolution(const QSize &resolution);
+    void setXZMeshResolution(const QSize &resolution);
     void setXYMeshResolution(const QSize &resolution);
-    QSize xyMeshResolution() const;
 
 Q_SIGNALS:
-    void xExtentChanged();
-    void yExtentChanged();
-    void zExtentChanged();
-
-    void yzMeshResolutionChanged();
-    void xzMeshResolutionChanged();
-    void xyMeshResolutionChanged();
-
+    void xExtentChanged(float xExtent);
+    void yExtentChanged(float yExtent);
+    void zExtentChanged(float zExtent);
 
+    void yzMeshResolutionChanged(const QSize &yzMeshResolution);
+    void xzMeshResolutionChanged(const QSize &xzMeshResolution);
+    void xyMeshResolutionChanged(const QSize &xyMeshResolution);
 
 private:
     // As this is a default provided geometry renderer, no one should be able
diff --git a/src/render/geometry/qcylindergeometry.cpp b/src/render/geometry/qcylindergeometry.cpp
index 9527fb476..8d8d293d8 100644
--- a/src/render/geometry/qcylindergeometry.cpp
+++ b/src/render/geometry/qcylindergeometry.cpp
@@ -387,7 +387,7 @@ void QCylinderGeometry::setRings(int rings)
         d->m_rings = rings;
         updateVertices();
         updateIndices();
-        emit ringsChanged();
+        emit ringsChanged(rings);
     }
 }
 
@@ -398,7 +398,7 @@ void QCylinderGeometry::setSlices(int slices)
         d->m_slices = slices;
         updateVertices();
         updateIndices();
-        emit slicesChanged();
+        emit slicesChanged(slices);
     }
 }
 
@@ -408,7 +408,7 @@ void QCylinderGeometry::setRadius(float radius)
     if (radius != d->m_radius) {
         d->m_radius = radius;
         updateVertices();
-        emit radiusChanged();
+        emit radiusChanged(radius);
     }
 }
 
@@ -419,7 +419,7 @@ void QCylinderGeometry::setLength(float length)
         d->m_length = length;
         updateVertices();
         updateIndices();
-        emit lengthChanged();
+        emit lengthChanged(length);
     }
 }
 
diff --git a/src/render/geometry/qcylindergeometry.h b/src/render/geometry/qcylindergeometry.h
index 501016ee1..74b520e0e 100644
--- a/src/render/geometry/qcylindergeometry.h
+++ b/src/render/geometry/qcylindergeometry.h
@@ -65,10 +65,6 @@ public:
 
     void updateVertices();
     void updateIndices();
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setLength(float length);
 
     int rings() const;
     int slices() const;
@@ -80,11 +76,17 @@ public:
     QAttribute *texCoordAttribute() const;
     QAttribute *indexAttribute() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setLength(float length);
+
 Q_SIGNALS:
-    void radiusChanged();
-    void ringsChanged();
-    void slicesChanged();
-    void lengthChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void lengthChanged(float length);
 
 protected:
     QCylinderGeometry(QCylinderGeometryPrivate &dd, QNode *parent = 0);
diff --git a/src/render/geometry/qcylindermesh.h b/src/render/geometry/qcylindermesh.h
index 30e888f14..93f28a092 100644
--- a/src/render/geometry/qcylindermesh.h
+++ b/src/render/geometry/qcylindermesh.h
@@ -56,21 +56,22 @@ public:
     explicit QCylinderMesh(Qt3DCore::QNode *parent = 0);
     ~QCylinderMesh();
 
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setLength(float length);
-
     int rings() const;
     int slices() const;
     float radius() const;
     float length() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setLength(float length);
+
 Q_SIGNALS:
-    void ringsChanged();
-    void slicesChanged();
-    void radiusChanged();
-    void lengthChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void lengthChanged(float length);
 
 private:
     // As this is a default provided geometry renderer, no one should be able
diff --git a/src/render/geometry/qgeometry.cpp b/src/render/geometry/qgeometry.cpp
index 0dca93336..10216b59c 100644
--- a/src/render/geometry/qgeometry.cpp
+++ b/src/render/geometry/qgeometry.cpp
@@ -47,7 +47,7 @@ using namespace Qt3DCore;
 
 namespace Qt3DRender {
 
-void QGeometryPrivate::_q_boundingVolumeSpecifierChanged()
+void QGeometryPrivate::_q_boundingVolumeSpecifierChanged(QAbstractAttribute *)
 {
     if (m_changeArbiter != Q_NULLPTR) {
         QScenePropertyChangePtr change(new QScenePropertyChange(NodeUpdated, QSceneChange::Node, m_id));
@@ -64,16 +64,16 @@ QGeometry::QGeometry(QNode *parent)
     : QNode(*new QGeometryPrivate(), parent)
 {
     Q_D(QGeometry);
-    QObject::connect(&d->m_boundingVolumeSpecifier, SIGNAL(positionAttributeChanged()),
-                     this, SLOT(_q_boundingVolumeSpecifierChanged()));
+    QObject::connect(&d->m_boundingVolumeSpecifier, SIGNAL(positionAttributeChanged(QAbstractAttribute *)),
+                     this, SLOT(_q_boundingVolumeSpecifierChanged(QAbstractAttribute *)));
 }
 
 QGeometry::QGeometry(QGeometryPrivate &dd, QNode *parent)
     : QNode(dd, parent)
 {
     Q_D(QGeometry);
-    QObject::connect(&d->m_boundingVolumeSpecifier, SIGNAL(positionAttributeChanged()),
-                     this, SLOT(_q_boundingVolumeSpecifierChanged()));
+    QObject::connect(&d->m_boundingVolumeSpecifier, SIGNAL(positionAttributeChanged(QAbstractAttribute *)),
+                     this, SLOT(_q_boundingVolumeSpecifierChanged(QAbstractAttribute *)));
 }
 
 QGeometry::~QGeometry()
@@ -120,7 +120,7 @@ void QGeometry::setVerticesPerPatch(int verticesPerPatch)
     Q_D(QGeometry);
     if (d->m_verticesPerPatch != verticesPerPatch) {
         d->m_verticesPerPatch = verticesPerPatch;
-        emit verticesPerPatchChanged();
+        emit verticesPerPatchChanged(verticesPerPatch);
     }
 }
 
diff --git a/src/render/geometry/qgeometry.h b/src/render/geometry/qgeometry.h
index f2ba6575e..5a8722383 100644
--- a/src/render/geometry/qgeometry.h
+++ b/src/render/geometry/qgeometry.h
@@ -63,13 +63,15 @@ public:
     void addAttribute(QAbstractAttribute *attribute);
     void removeAttribute(QAbstractAttribute *attribute);
 
-    void setVerticesPerPatch(int verticesPerPatch);
     int verticesPerPatch() const;
 
     QBoundingVolumeSpecifier *boundingVolumeSpecifier();
 
+public Q_SLOTS:
+    void setVerticesPerPatch(int verticesPerPatch);
+
 Q_SIGNALS:
-    void verticesPerPatchChanged();
+    void verticesPerPatchChanged(int verticesPerPatch);
 
 protected:
     QGeometry(QGeometryPrivate &dd, Qt3DCore::QNode *parent = 0);
@@ -78,7 +80,7 @@ protected:
 private:
     Q_DECLARE_PRIVATE(QGeometry)
     QT3D_CLONEABLE(QGeometry)
-    Q_PRIVATE_SLOT(d_func(), void _q_boundingVolumeSpecifierChanged())
+    Q_PRIVATE_SLOT(d_func(), void _q_boundingVolumeSpecifierChanged(QAbstractAttribute *))
 };
 
 } // namespace Qt3DRender
diff --git a/src/render/geometry/qgeometry_p.h b/src/render/geometry/qgeometry_p.h
index d315b82dd..8f4119d3a 100644
--- a/src/render/geometry/qgeometry_p.h
+++ b/src/render/geometry/qgeometry_p.h
@@ -69,7 +69,7 @@ public:
     QBoundingVolumeSpecifier m_boundingVolumeSpecifier;
 
 private:
-    void _q_boundingVolumeSpecifierChanged();
+    void _q_boundingVolumeSpecifierChanged(Qt3DRender::QAbstractAttribute *);
 };
 
 } // namespace Qt3DRender
diff --git a/src/render/geometry/qgeometryrenderer.cpp b/src/render/geometry/qgeometryrenderer.cpp
index cb0e9abb8..29a75ffc4 100644
--- a/src/render/geometry/qgeometryrenderer.cpp
+++ b/src/render/geometry/qgeometryrenderer.cpp
@@ -135,7 +135,7 @@ void QGeometryRenderer::setInstanceCount(int instanceCount)
         return;
 
     d->m_instanceCount = instanceCount;
-    emit instanceCountChanged();
+    emit instanceCountChanged(instanceCount);
 }
 
 void QGeometryRenderer::setPrimitiveCount(int primitiveCount)
@@ -145,7 +145,7 @@ void QGeometryRenderer::setPrimitiveCount(int primitiveCount)
         return;
 
     d->m_primitiveCount = primitiveCount;
-    emit primitiveCountChanged();
+    emit primitiveCountChanged(primitiveCount);
 }
 
 void QGeometryRenderer::setBaseVertex(int baseVertex)
@@ -155,7 +155,7 @@ void QGeometryRenderer::setBaseVertex(int baseVertex)
         return;
 
     d->m_baseVertex = baseVertex;
-    emit baseVertexChanged();
+    emit baseVertexChanged(baseVertex);
 }
 
 void QGeometryRenderer::setBaseInstance(int baseInstance)
@@ -165,7 +165,7 @@ void QGeometryRenderer::setBaseInstance(int baseInstance)
         return;
 
     d->m_baseInstance = baseInstance;
-    emit baseInstanceChanged();
+    emit baseInstanceChanged(baseInstance);
 }
 
 void QGeometryRenderer::setRestartIndex(int index)
@@ -175,7 +175,7 @@ void QGeometryRenderer::setRestartIndex(int index)
         return;
 
     d->m_restartIndex = index;
-    emit restartIndexChanged();
+    emit restartIndexChanged(index);
 }
 
 void QGeometryRenderer::setPrimitiveRestart(bool enabled)
@@ -185,7 +185,7 @@ void QGeometryRenderer::setPrimitiveRestart(bool enabled)
         return;
 
     d->m_primitiveRestart = enabled;
-    emit primitiveRestartChanged();
+    emit primitiveRestartChanged(enabled);
 }
 
 void QGeometryRenderer::setGeometry(QGeometry *geometry)
@@ -206,7 +206,7 @@ void QGeometryRenderer::setGeometry(QGeometry *geometry)
 
     d->m_geometry = geometry;
     const bool blocked = blockNotifications(true);
-    emit geometryChanged();
+    emit geometryChanged(geometry);
     blockNotifications(blocked);
 
     if (d->m_geometry && d->m_changeArbiter) {
@@ -224,7 +224,7 @@ void QGeometryRenderer::setPrimitiveType(QGeometryRenderer::PrimitiveType primit
         return;
 
     d->m_primitiveType = primitiveType;
-    emit primitiveTypeChanged();
+    emit primitiveTypeChanged(primitiveType);
 }
 
 void QGeometryRenderer::setGeometryFunctor(const QGeometryFunctorPtr &functor)
diff --git a/src/render/geometry/qgeometryrenderer.h b/src/render/geometry/qgeometryrenderer.h
index 4898b15bc..e58b648b3 100644
--- a/src/render/geometry/qgeometryrenderer.h
+++ b/src/render/geometry/qgeometryrenderer.h
@@ -93,8 +93,11 @@ public:
     bool primitiveRestart() const;
     QGeometry *geometry() const;
     PrimitiveType primitiveType() const;
+
     QGeometryFunctorPtr geometryFunctor() const;
+    void setGeometryFunctor(const QGeometryFunctorPtr &functor);
 
+public Q_SLOTS:
     void setInstanceCount(int instanceCount);
     void setPrimitiveCount(int primitiveCount);
     void setBaseVertex(int baseVertex);
@@ -103,17 +106,16 @@ public:
     void setPrimitiveRestart(bool enabled);
     void setGeometry(QGeometry *geometry);
     void setPrimitiveType(PrimitiveType primitiveType);
-    void setGeometryFunctor(const QGeometryFunctorPtr &functor);
 
 Q_SIGNALS:
-    void instanceCountChanged();
-    void primitiveCountChanged();
-    void baseVertexChanged();
-    void baseInstanceChanged();
-    void restartIndexChanged();
-    void primitiveRestartChanged();
-    void geometryChanged();
-    void primitiveTypeChanged();
+    void instanceCountChanged(int instanceCount);
+    void primitiveCountChanged(int primitiveCount);
+    void baseVertexChanged(int baseVertex);
+    void baseInstanceChanged(int baseInstance);
+    void restartIndexChanged(int restartIndex);
+    void primitiveRestartChanged(bool primitiveRestart);
+    void geometryChanged(QGeometry *geometry);
+    void primitiveTypeChanged(PrimitiveType primitiveType);
 
 protected:
     QGeometryRenderer(QGeometryRendererPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/geometry/qmesh.cpp b/src/render/geometry/qmesh.cpp
index bb45b61a7..873769bd7 100644
--- a/src/render/geometry/qmesh.cpp
+++ b/src/render/geometry/qmesh.cpp
@@ -96,7 +96,7 @@ void QMesh::setSource(const QUrl& source)
     d->m_source = source;
     // update the functor
     QGeometryRenderer::setGeometryFunctor(QGeometryFunctorPtr(new MeshFunctor(d->m_source, d->m_subMesh)));
-    emit sourceChanged();
+    emit sourceChanged(source);
 }
 
 QUrl QMesh::source() const
@@ -113,7 +113,7 @@ void QMesh::setSubMesh(const QString &subMesh)
     d->m_subMesh = subMesh;
     // update the functor
     QGeometryRenderer::setGeometryFunctor(QGeometryFunctorPtr(new MeshFunctor(d->m_source, d->m_subMesh)));
-    emit subMeshChanged();
+    emit subMeshChanged(subMesh);
 }
 
 QString QMesh::subMesh() const
diff --git a/src/render/geometry/qmesh.h b/src/render/geometry/qmesh.h
index a0d409b2e..58985789a 100644
--- a/src/render/geometry/qmesh.h
+++ b/src/render/geometry/qmesh.h
@@ -61,15 +61,16 @@ public:
     explicit QMesh(Qt3DCore::QNode *parent = 0);
     ~QMesh();
 
-    void setSource(const QUrl &source);
     QUrl source() const;
+    QString subMesh() const;
 
+public Q_SLOTS:
+    void setSource(const QUrl &source);
     void setSubMesh(const QString &subMesh);
-    QString subMesh() const;
 
 Q_SIGNALS:
-    void sourceChanged();
-    void subMeshChanged();
+    void sourceChanged(const QUrl &source);
+    void subMeshChanged(const QString &subMesh);
 
 protected:
     QMesh(QMeshPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/geometry/qplanegeometry.cpp b/src/render/geometry/qplanegeometry.cpp
index d5b419502..ad571dbb4 100644
--- a/src/render/geometry/qplanegeometry.cpp
+++ b/src/render/geometry/qplanegeometry.cpp
@@ -250,7 +250,7 @@ void QPlaneGeometry::setResolution(const QSize &resolution)
     d->m_meshResolution = resolution;
     updateVertices();
     updateIndices();
-    emit resolutionChanged();
+    emit resolutionChanged(resolution);
 }
 
 void QPlaneGeometry::setWidth(float width)
@@ -260,7 +260,7 @@ void QPlaneGeometry::setWidth(float width)
         return;
     d->m_width = width;
     updateVertices();
-    emit widthChanged();
+    emit widthChanged(width);
 }
 
 void QPlaneGeometry::setHeight(float height)
@@ -270,7 +270,7 @@ void QPlaneGeometry::setHeight(float height)
         return;
     d->m_height = height;
     updateVertices();
-    emit heightChanged();
+    emit heightChanged(height);
 }
 
 QSize QPlaneGeometry::resolution() const
diff --git a/src/render/geometry/qplanegeometry.h b/src/render/geometry/qplanegeometry.h
index d3a41d0d2..cd99a6cde 100644
--- a/src/render/geometry/qplanegeometry.h
+++ b/src/render/geometry/qplanegeometry.h
@@ -66,10 +66,6 @@ public:
     void updateVertices();
     void updateIndices();
 
-    void setResolution(const QSize &resolution);
-    void setWidth(float width);
-    void setHeight(float height);
-
     QSize resolution() const;
     float width() const;
     float height() const;
@@ -80,10 +76,15 @@ public:
     QAttribute *tangentAttribute() const;
     QAttribute *indexAttribute() const;
 
+public Q_SLOTS:
+    void setResolution(const QSize &resolution);
+    void setWidth(float width);
+    void setHeight(float height);
+
 Q_SIGNALS:
-    void resolutionChanged();
-    void widthChanged();
-    void heightChanged();
+    void resolutionChanged(const QSize &resolution);
+    void widthChanged(float width);
+    void heightChanged(float height);
 
 protected:
     QPlaneGeometry(QPlaneGeometryPrivate &dd, QNode *parent = Q_NULLPTR);
diff --git a/src/render/geometry/qplanemesh.h b/src/render/geometry/qplanemesh.h
index 0a730ca6a..e5db1a099 100644
--- a/src/render/geometry/qplanemesh.h
+++ b/src/render/geometry/qplanemesh.h
@@ -56,19 +56,19 @@ public:
     explicit QPlaneMesh(Qt3DCore::QNode *parent = 0);
     ~QPlaneMesh();
 
-    void setWidth(float width);
     float width() const;
-
-    void setHeight(float height);
     float height() const;
+    QSize meshResolution() const;
 
+public Q_SLOTS:
+    void setWidth(float width);
+    void setHeight(float height);
     void setMeshResolution(const QSize &resolution);
-    QSize meshResolution() const;
 
 Q_SIGNALS:
-    void widthChanged();
-    void heightChanged();
-    void meshResolutionChanged();
+    void meshResolutionChanged(const QSize &meshResolution);
+    void widthChanged(float width);
+    void heightChanged(float height);
 
 private:
     // As this is a default provided geometry renderer, no one should be able
diff --git a/src/render/geometry/qspheregeometry.cpp b/src/render/geometry/qspheregeometry.cpp
index ee11812dc..2496b3e41 100644
--- a/src/render/geometry/qspheregeometry.cpp
+++ b/src/render/geometry/qspheregeometry.cpp
@@ -354,7 +354,7 @@ void QSphereGeometry::setRings(int rings)
         d->m_rings = rings;
         updateVertices();
         updateIndices();
-        emit ringsChanged();
+        emit ringsChanged(rings);
     }
 }
 
@@ -365,7 +365,7 @@ void QSphereGeometry::setSlices(int slices)
         d->m_slices = slices;
         updateVertices();
         updateIndices();
-        emit slicesChanged();
+        emit slicesChanged(slices);
     }
 }
 
@@ -375,7 +375,7 @@ void QSphereGeometry::setRadius(float radius)
     if (radius != d->m_radius) {
         d->m_radius = radius;
         updateVertices();
-        emit radiusChanged();
+        emit radiusChanged(radius);
     }
 }
 
@@ -388,7 +388,7 @@ void QSphereGeometry::setGenerateTangents(bool gen)
         d->m_generateTangents = gen;
         if (d->m_generateTangents)
             addAttribute(d->m_tangentAttribute);
-        emit generateTangentsChanged();
+        emit generateTangentsChanged(gen);
     }
 }
 
diff --git a/src/render/geometry/qspheregeometry.h b/src/render/geometry/qspheregeometry.h
index e663a86f2..10a90a3e1 100644
--- a/src/render/geometry/qspheregeometry.h
+++ b/src/render/geometry/qspheregeometry.h
@@ -65,10 +65,6 @@ public:
 
     void updateVertices();
     void updateIndices();
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setGenerateTangents(bool gen);
 
     bool generateTangents() const;
     int rings() const;
@@ -81,11 +77,17 @@ public:
     QAttribute *tangentAttribute() const;
     QAttribute *indexAttribute() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setGenerateTangents(bool gen);
+
 Q_SIGNALS:
-    void radiusChanged();
-    void ringsChanged();
-    void slicesChanged();
-    void generateTangentsChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void generateTangentsChanged(bool generateTangents);
 
 protected:
     QSphereGeometry(QSphereGeometryPrivate &dd, QNode *parent = Q_NULLPTR);
diff --git a/src/render/geometry/qspheremesh.h b/src/render/geometry/qspheremesh.h
index 9ac2ac281..a80f7f0c9 100644
--- a/src/render/geometry/qspheremesh.h
+++ b/src/render/geometry/qspheremesh.h
@@ -58,21 +58,22 @@ public:
     explicit QSphereMesh(Qt3DCore::QNode *parent = 0);
     ~QSphereMesh();
 
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setGenerateTangents(bool gen);
-
     int rings() const;
     int slices() const;
     float radius() const;
     bool generateTangents() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setGenerateTangents(bool gen);
+
 Q_SIGNALS:
-    void radiusChanged();
-    void ringsChanged();
-    void slicesChanged();
-    void generateTangentsChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void generateTangentsChanged(bool generateTangents);
 
 private:
     // As this is a default provided geometry renderer, no one should be able
diff --git a/src/render/geometry/qtorusgeometry.cpp b/src/render/geometry/qtorusgeometry.cpp
index ff28f348e..d2d4fae4a 100644
--- a/src/render/geometry/qtorusgeometry.cpp
+++ b/src/render/geometry/qtorusgeometry.cpp
@@ -302,7 +302,7 @@ void QTorusGeometry::setRings(int rings)
         d->m_rings = rings;
         updateVertices();
         updateIndices();
-        emit ringsChanged();
+        emit ringsChanged(rings);
     }
 }
 
@@ -313,7 +313,7 @@ void QTorusGeometry::setSlices(int slices)
         d->m_slices = slices;
         updateVertices();
         updateIndices();
-        emit slicesChanged();
+        emit slicesChanged(slices);
     }
 }
 
@@ -323,7 +323,7 @@ void QTorusGeometry::setRadius(float radius)
     if (radius != d->m_radius) {
         d->m_radius = radius;
         updateVertices();
-        emit radiusChanged();
+        emit radiusChanged(radius);
     }
 }
 
@@ -333,7 +333,7 @@ void QTorusGeometry::setMinorRadius(float minorRadius)
     if (minorRadius != d->m_minorRadius) {
         d->m_minorRadius = minorRadius;
         updateVertices();
-        emit minorRadiusChanged();
+        emit minorRadiusChanged(minorRadius);
     }
 }
 
diff --git a/src/render/geometry/qtorusgeometry.h b/src/render/geometry/qtorusgeometry.h
index 7a935231a..08a82a0f3 100644
--- a/src/render/geometry/qtorusgeometry.h
+++ b/src/render/geometry/qtorusgeometry.h
@@ -65,10 +65,6 @@ public:
 
     void updateVertices();
     void updateIndices();
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setMinorRadius(float minorRadius);
 
     int rings() const;
     int slices() const;
@@ -80,11 +76,17 @@ public:
     QAttribute *texCoordAttribute() const;
     QAttribute *indexAttribute() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setMinorRadius(float minorRadius);
+
 Q_SIGNALS:
-    void radiusChanged();
-    void ringsChanged();
-    void slicesChanged();
-    void minorRadiusChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void minorRadiusChanged(float minorRadius);
 
 
 protected:
diff --git a/src/render/geometry/qtorusmesh.h b/src/render/geometry/qtorusmesh.h
index 6b470b1b1..c04d7fbc7 100644
--- a/src/render/geometry/qtorusmesh.h
+++ b/src/render/geometry/qtorusmesh.h
@@ -55,21 +55,22 @@ public:
     explicit QTorusMesh(Qt3DCore::QNode *parent = 0);
     ~QTorusMesh();
 
-    void setRings(int rings);
-    void setSlices(int slices);
-    void setRadius(float radius);
-    void setMinorRadius(float minorRadius);
-
     int rings() const;
     int slices() const;
     float radius() const;
     float minorRadius() const;
 
+public Q_SLOTS:
+    void setRings(int rings);
+    void setSlices(int slices);
+    void setRadius(float radius);
+    void setMinorRadius(float minorRadius);
+
 Q_SIGNALS:
-    void radiusChanged();
-    void minorRadiusChanged();
-    void ringsChanged();
-    void slicesChanged();
+    void radiusChanged(float radius);
+    void ringsChanged(int rings);
+    void slicesChanged(int slices);
+    void minorRadiusChanged(float minorRadius);
 
 private:
     // As this is a default provided geometry renderer, no one should be able
diff --git a/src/render/io/qabstractsceneloader.cpp b/src/render/io/qabstractsceneloader.cpp
index 6c90c15ad..7894d4d3d 100644
--- a/src/render/io/qabstractsceneloader.cpp
+++ b/src/render/io/qabstractsceneloader.cpp
@@ -88,7 +88,7 @@ void QAbstractSceneLoader::setSource(const QUrl &arg)
     Q_D(QAbstractSceneLoader);
     if (d->m_source != arg) {
         d->m_source = arg;
-        emit sourceChanged();
+        emit sourceChanged(arg);
     }
 }
 
@@ -103,7 +103,7 @@ void QAbstractSceneLoader::setStatus(QAbstractSceneLoader::Status status)
     Q_D(QAbstractSceneLoader);
     if (d->m_status != status) {
         d->m_status = status;
-        emit statusChanged();
+        emit statusChanged(status);
     }
 }
 
diff --git a/src/render/io/qabstractsceneloader.h b/src/render/io/qabstractsceneloader.h
index e4f19eb12..599ca1fc7 100644
--- a/src/render/io/qabstractsceneloader.h
+++ b/src/render/io/qabstractsceneloader.h
@@ -66,14 +66,15 @@ public:
     Q_ENUM(Status)
 
     QUrl source() const;
-    void setSource(const QUrl &arg);
-
     Status status() const;
+
+public Q_SLOTS:
+    void setSource(const QUrl &arg);
     void setStatus(Status status);
 
 Q_SIGNALS:
-    void sourceChanged();
-    void statusChanged();
+    void sourceChanged(const QUrl &source);
+    void statusChanged(Status status);
 
 protected:
     QAbstractSceneLoader(QAbstractSceneLoaderPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/io/qabstractsceneparser.cpp b/src/render/io/qabstractsceneparser.cpp
index 0a5378541..d26e99a13 100644
--- a/src/render/io/qabstractsceneparser.cpp
+++ b/src/render/io/qabstractsceneparser.cpp
@@ -65,14 +65,14 @@ void QAbstractSceneParser::setParserStatus(ParserStatus parserStatus)
 {
     if (parserStatus != m_parserStatus) {
         m_parserStatus = parserStatus;
-        emit parserStatusChanged();
+        emit parserStatusChanged(parserStatus);
     }
 }
 
 void QAbstractSceneParser::logError(const QString &error)
 {
     m_errors.append(error);
-    emit errorsChanged();
+    emit errorsChanged(m_errors);
 }
 
 void QAbstractSceneParser::logInfo(const QString &info)
diff --git a/src/render/io/qabstractsceneparser.h b/src/render/io/qabstractsceneparser.h
index 3f1681e3a..a91d392e9 100644
--- a/src/render/io/qabstractsceneparser.h
+++ b/src/render/io/qabstractsceneparser.h
@@ -80,8 +80,8 @@ public:
     QStringList errors() const;
 
 Q_SIGNALS:
-    void parserStatusChanged();
-    void errorsChanged();
+    void parserStatusChanged(ParserStatus parserStatus);
+    void errorsChanged(const QStringList &errors);
 
 protected:
     void setParserStatus(ParserStatus parserStatus);
diff --git a/src/render/lights/qdirectionallight.cpp b/src/render/lights/qdirectionallight.cpp
index 206b720b0..9a5dfdd97 100644
--- a/src/render/lights/qdirectionallight.cpp
+++ b/src/render/lights/qdirectionallight.cpp
@@ -96,7 +96,7 @@ void QDirectionalLight::setDirection(const QVector3D &direction)
     Q_D(QDirectionalLight);
     if (direction != d->m_direction) {
         d->m_direction = direction;
-        emit directionChanged();
+        emit directionChanged(direction);
     }
 }
 
diff --git a/src/render/lights/qdirectionallight.h b/src/render/lights/qdirectionallight.h
index c2af37ea5..bffb601a5 100644
--- a/src/render/lights/qdirectionallight.h
+++ b/src/render/lights/qdirectionallight.h
@@ -53,11 +53,13 @@ class QT3DRENDERSHARED_EXPORT QDirectionalLight : public QLight
 public:
     explicit QDirectionalLight(Qt3DCore::QNode *parent = 0);
 
-    void setDirection(const QVector3D &direction);
     QVector3D direction() const;
 
+public Q_SLOTS:
+    void setDirection(const QVector3D &direction);
+
 Q_SIGNALS:
-    void directionChanged();
+    void directionChanged(const QVector3D &direction);
 
 protected:
     QDirectionalLight(QDirectionalLightPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/lights/qlight.cpp b/src/render/lights/qlight.cpp
index 55fe1415a..77cf4efe1 100644
--- a/src/render/lights/qlight.cpp
+++ b/src/render/lights/qlight.cpp
@@ -106,7 +106,7 @@ void QLight::setType(Type type)
     Q_D(QLight);
     if (d->m_type != type) {
         d->m_type = type;
-        emit typeChanged();
+        emit typeChanged(type);
     }
 }
 
@@ -126,7 +126,7 @@ void QLight::setColor(const QColor &color)
     Q_D(QLight);
     if (d->m_color != color) {
         d->m_color = color;
-        emit colorChanged();
+        emit colorChanged(color);
     }
 }
 
@@ -146,7 +146,7 @@ void QLight::setIntensity(float intensity)
     Q_D(QLight);
     if (d->m_intensity != intensity) {
         d->m_intensity = intensity;
-        emit intensityChanged();
+        emit intensityChanged(intensity);
     }
 }
 
diff --git a/src/render/lights/qlight.h b/src/render/lights/qlight.h
index d1ce2e463..febff442c 100644
--- a/src/render/lights/qlight.h
+++ b/src/render/lights/qlight.h
@@ -68,12 +68,12 @@ public :
     ~QLight();
 
     Type type() const;
-    void setType(Type type);
-
     QColor color() const;
-    void setColor(const QColor &color);
-
     float intensity() const;
+
+public Q_SLOTS:
+    void setType(Type type);
+    void setColor(const QColor &color);
     void setIntensity(float intensity);
 
 protected :
@@ -81,9 +81,9 @@ protected :
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
 
 Q_SIGNALS:
-    void typeChanged();
-    void colorChanged();
-    void intensityChanged();
+    void typeChanged(Type type);
+    void colorChanged(const QColor &color);
+    void intensityChanged(float intensity);
 
 private:
     Q_DECLARE_PRIVATE(QLight)
diff --git a/src/render/lights/qpointlight.cpp b/src/render/lights/qpointlight.cpp
index d795a9914..05fb85676 100644
--- a/src/render/lights/qpointlight.cpp
+++ b/src/render/lights/qpointlight.cpp
@@ -110,7 +110,7 @@ void QPointLight::setAttenuation(const QVector3D &value)
     Q_D(QPointLight);
     if (d->m_attenuation != value) {
         d->m_attenuation = value;
-        emit attenuationChanged();
+        emit attenuationChanged(value);
     }
 }
 
@@ -125,7 +125,7 @@ void QPointLight::setConstantAttenuation(float value)
     Q_D(QPointLight);
     if (d->m_attenuation.x() != value) {
         d->m_attenuation.setX(value);
-        emit attenuationChanged();
+        emit attenuationChanged(d->m_attenuation);
     }
 }
 
@@ -140,7 +140,7 @@ void QPointLight::setLinearAttenuation(float value)
     Q_D(QPointLight);
     if (d->m_attenuation.y() != value) {
         d->m_attenuation.setY(value);
-        emit attenuationChanged();
+        emit attenuationChanged(d->m_attenuation);
     }
 }
 
@@ -155,7 +155,7 @@ void QPointLight::setQuadraticAttenuation(float value)
     Q_D(QPointLight);
     if (d->m_attenuation.z() != value) {
         d->m_attenuation.setZ(value);
-        emit attenuationChanged();
+        emit attenuationChanged(d->m_attenuation);
     }
 }
 
diff --git a/src/render/lights/qpointlight.h b/src/render/lights/qpointlight.h
index 75b4671d0..62e8ebcb6 100644
--- a/src/render/lights/qpointlight.h
+++ b/src/render/lights/qpointlight.h
@@ -54,7 +54,6 @@ public:
     explicit QPointLight(Qt3DCore::QNode *parent = 0);
 
     QVector3D attenuation() const;
-    void setAttenuation(const QVector3D &value);
 
     float constantAttenuation() const;
     void setConstantAttenuation(float value);
@@ -65,8 +64,11 @@ public:
     float quadraticAttenuation() const;
     void setQuadraticAttenuation(float value);
 
+public Q_SLOTS:
+    void setAttenuation(const QVector3D &value);
+
 Q_SIGNALS:
-    void attenuationChanged();
+    void attenuationChanged(const QVector3D &attenuation);
 
 protected:
     Q_DECLARE_PRIVATE(QPointLight)
diff --git a/src/render/lights/qspotlight.cpp b/src/render/lights/qspotlight.cpp
index 6b8bf6906..13c81b494 100644
--- a/src/render/lights/qspotlight.cpp
+++ b/src/render/lights/qspotlight.cpp
@@ -153,7 +153,7 @@ void QSpotLight::setDirection(const QVector3D &direction)
     Q_D(QSpotLight);
     if (direction != d->m_direction) {
         d->m_direction = direction;
-        emit directionChanged();
+        emit directionChanged(direction);
     }
 }
 
@@ -162,7 +162,7 @@ void QSpotLight::setCutOffAngle(float cutOffAngle)
     Q_D(QSpotLight);
     if (d->m_cutOffAngle != cutOffAngle) {
         d->m_cutOffAngle = cutOffAngle;
-        emit cutOffAngleChanged();
+        emit cutOffAngleChanged(cutOffAngle);
     }
 }
 
diff --git a/src/render/lights/qspotlight.h b/src/render/lights/qspotlight.h
index 9a04b7925..edba764cc 100644
--- a/src/render/lights/qspotlight.h
+++ b/src/render/lights/qspotlight.h
@@ -57,12 +57,13 @@ public:
     QVector3D direction() const;
     float cutOffAngle() const;
 
+public Q_SLOTS:
     void setDirection(const QVector3D &direction);
     void setCutOffAngle(float cutOffAngle);
 
 Q_SIGNALS:
-    void directionChanged();
-    void cutOffAngleChanged();
+    void directionChanged(const QVector3D &direction);
+    void cutOffAngleChanged(float cutOffAngle);
 
 protected:
     QSpotLight(QSpotLightPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/materialsystem/qannotation.cpp b/src/render/materialsystem/qannotation.cpp
index 6c85da927..4660f039d 100644
--- a/src/render/materialsystem/qannotation.cpp
+++ b/src/render/materialsystem/qannotation.cpp
@@ -98,7 +98,7 @@ void QAnnotation::setValue(const QVariant &value)
     Q_D(QAnnotation);
     if (value != d->m_value) {
         d->m_value = value;
-        emit valueChanged();
+        emit valueChanged(value);
     }
 }
 
@@ -107,7 +107,7 @@ void QAnnotation::setName(const QString &name)
     Q_D(QAnnotation);
     if (name != d->m_name) {
         d->m_name = name;
-        emit nameChanged();
+        emit nameChanged(name);
     }
 }
 
diff --git a/src/render/materialsystem/qannotation.h b/src/render/materialsystem/qannotation.h
index 28b2e87d8..1cf73186d 100644
--- a/src/render/materialsystem/qannotation.h
+++ b/src/render/materialsystem/qannotation.h
@@ -56,15 +56,16 @@ public:
     explicit QAnnotation(Qt3DCore::QNode *parent = 0);
     ~QAnnotation();
 
-    void setValue(const QVariant &value);
-    void setName(const QString &customType);
-
     QVariant value() const;
     QString name() const;
 
+public Q_SLOTS:
+    void setValue(const QVariant &value);
+    void setName(const QString &customType);
+
 Q_SIGNALS:
-    void nameChanged();
-    void valueChanged();
+    void nameChanged(const QString &name);
+    void valueChanged(const QVariant &value);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/materialsystem/qgraphicsapifilter.cpp b/src/render/materialsystem/qgraphicsapifilter.cpp
index 127426f62..8a8155ca4 100644
--- a/src/render/materialsystem/qgraphicsapifilter.cpp
+++ b/src/render/materialsystem/qgraphicsapifilter.cpp
@@ -225,7 +225,7 @@ void QGraphicsApiFilter::setApi(QGraphicsApiFilter::Api api)
     Q_D(QGraphicsApiFilter);
     if (d->m_api != api) {
         d->m_api = api;
-        emit apiChanged();
+        emit apiChanged(api);
         emit graphicsApiFilterChanged();
     }
 }
@@ -235,7 +235,7 @@ void QGraphicsApiFilter::setProfile(QGraphicsApiFilter::Profile profile)
     Q_D(QGraphicsApiFilter);
     if (d->m_profile != profile) {
         d->m_profile = profile;
-        emit profileChanged();
+        emit profileChanged(profile);
         emit graphicsApiFilterChanged();
     }
 }
@@ -245,7 +245,7 @@ void QGraphicsApiFilter::setMinorVersion(int minorVersion)
     Q_D(QGraphicsApiFilter);
     if (minorVersion != d->m_minor) {
         d->m_minor = minorVersion;
-        emit minorVersionChanged();
+        emit minorVersionChanged(minorVersion);
         emit graphicsApiFilterChanged();
     }
 }
@@ -255,7 +255,7 @@ void QGraphicsApiFilter::setMajorVersion(int majorVersion)
     Q_D(QGraphicsApiFilter);
     if (d->m_major != majorVersion) {
         d->m_major = majorVersion;
-        emit majorVersionChanged();
+        emit majorVersionChanged(majorVersion);
         emit graphicsApiFilterChanged();
     }
 }
@@ -265,7 +265,7 @@ void QGraphicsApiFilter::setExtensions(const QStringList &extensions)
     Q_D(QGraphicsApiFilter);
     if (d->m_extensions != extensions) {
         d->m_extensions = extensions;
-        emit extensionsChanged();
+        emit extensionsChanged(extensions);
         emit graphicsApiFilterChanged();
     }
 }
@@ -275,7 +275,7 @@ void QGraphicsApiFilter::setVendor(const QString &vendor)
     Q_D(QGraphicsApiFilter);
     if (d->m_vendor != vendor) {
         d->m_vendor = vendor;
-        emit vendorChanged();
+        emit vendorChanged(vendor);
         emit graphicsApiFilterChanged();
     }
 }
diff --git a/src/render/materialsystem/qgraphicsapifilter.h b/src/render/materialsystem/qgraphicsapifilter.h
index 31a176532..8ebf44096 100644
--- a/src/render/materialsystem/qgraphicsapifilter.h
+++ b/src/render/materialsystem/qgraphicsapifilter.h
@@ -86,6 +86,7 @@ public:
     QStringList extensions() const;
     QString vendor() const;
 
+public Q_SLOTS:
     void setApi(Api api);
     void setProfile(Profile profile);
     void setMinorVersion(int minorVersion);
@@ -94,12 +95,12 @@ public:
     void setVendor(const QString &vendor);
 
 Q_SIGNALS:
-    void apiChanged();
-    void profileChanged();
-    void minorVersionChanged();
-    void majorVersionChanged();
-    void extensionsChanged();
-    void vendorChanged();
+    void apiChanged(Api api);
+    void profileChanged(Profile profile);
+    void minorVersionChanged(int minorVersion);
+    void majorVersionChanged(int majorVersion);
+    void extensionsChanged(const QStringList &extensions);
+    void vendorChanged(const QString &vendor);
     void graphicsApiFilterChanged();
 
 private:
diff --git a/src/render/materialsystem/qmaterial.cpp b/src/render/materialsystem/qmaterial.cpp
index 48d7f3845..ceb16db57 100644
--- a/src/render/materialsystem/qmaterial.cpp
+++ b/src/render/materialsystem/qmaterial.cpp
@@ -120,7 +120,7 @@ void QMaterial::setEffect(QEffect *effect)
         if (effect && !effect->parent())
             effect->setParent(this);
         d->m_effect = effect;
-        emit effectChanged();
+        emit effectChanged(effect);
     }
 }
 
diff --git a/src/render/materialsystem/qmaterial.h b/src/render/materialsystem/qmaterial.h
index daf580c11..cfb0bad48 100644
--- a/src/render/materialsystem/qmaterial.h
+++ b/src/render/materialsystem/qmaterial.h
@@ -61,7 +61,6 @@ public:
     explicit QMaterial(Qt3DCore::QNode *parent = 0);
     ~QMaterial();
 
-    void setEffect(QEffect *effect);
     QEffect *effect() const;
 
     void addParameter(QParameter *parameter);
@@ -72,8 +71,11 @@ public:
 
     void setTextureParameter(QString name, QAbstractTextureProvider* tex);
 
+public Q_SLOTS:
+    void setEffect(QEffect *effect);
+
 Q_SIGNALS:
-    void effectChanged();
+    void effectChanged(QEffect *effect);
 
 protected:
     QMaterial(QMaterialPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/materialsystem/qparameter.cpp b/src/render/materialsystem/qparameter.cpp
index 2535d5608..62e38e3b3 100644
--- a/src/render/materialsystem/qparameter.cpp
+++ b/src/render/materialsystem/qparameter.cpp
@@ -106,7 +106,7 @@ void QParameter::setName(const QString &name)
     Q_D(QParameter);
     if (d->m_name != name) {
         d->m_name = name;
-        emit nameChanged();
+        emit nameChanged(name);
     }
 }
 
@@ -121,7 +121,7 @@ void QParameter::setValue(const QVariant &dv)
     Q_D(QParameter);
     if (d->m_value != dv) {
         d->setValue(dv);
-        emit valueChanged();
+        emit valueChanged(dv);
 
         // In case texture are declared inline
         QNode *txt = dv.value<QNode *>();
diff --git a/src/render/materialsystem/qparameter.h b/src/render/materialsystem/qparameter.h
index 5278829c6..94b0f2889 100644
--- a/src/render/materialsystem/qparameter.h
+++ b/src/render/materialsystem/qparameter.h
@@ -57,22 +57,24 @@ class QT3DRENDERSHARED_EXPORT QParameter : public Qt3DCore::QNode
 public:
     explicit QParameter(Qt3DCore::QNode *parent = 0);
     ~QParameter();
-    QParameter(const QString& name, const QVariant& value, Qt3DCore::QNode* parent = 0);
+    QParameter(const QString &name, const QVariant& value, Qt3DCore::QNode *parent = 0);
     QParameter(const QString &name, QAbstractTextureProvider *texture, Qt3DCore::QNode *parent = 0);
 
-    void setName(const QString &name);
     QString name() const;
 
     /**
      * @brief setDefaultValue - for non-texture uniform parameters
      * @param dv
      */
-    void setValue(const QVariant& dv);
     QVariant value() const;
 
+public Q_SLOTS:
+    void setName(const QString &name);
+    void setValue(const QVariant &dv);
+
 Q_SIGNALS:
-    void valueChanged();
-    void nameChanged();
+    void valueChanged(const QVariant &value);
+    void nameChanged(const QString &name);
 
 protected:
     QParameter(QParameterPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/materialsystem/qparametermapping.cpp b/src/render/materialsystem/qparametermapping.cpp
index 95234889c..5ac841142 100644
--- a/src/render/materialsystem/qparametermapping.cpp
+++ b/src/render/materialsystem/qparametermapping.cpp
@@ -135,7 +135,7 @@ void QParameterMapping::setParameterName(const QString &name)
     Q_D(QParameterMapping);
     if (d->m_parameterName != name) {
         d->m_parameterName = name;
-        emit parameterNameChanged();
+        emit parameterNameChanged(name);
     }
 }
 
@@ -154,7 +154,7 @@ void QParameterMapping::setShaderVariableName(const QString &name)
     Q_D(QParameterMapping);
     if (d->m_shaderVariableName != name) {
         d->m_shaderVariableName = name;
-        emit shaderVariableNameChanged();
+        emit shaderVariableNameChanged(name);
     }
 }
 
@@ -176,7 +176,7 @@ void QParameterMapping::setBindingType(QParameterMapping::Binding type)
     Q_D(QParameterMapping);
     if (d->m_bindingType != type) {
         d->m_bindingType = type;
-        emit bindingTypeChanged();
+        emit bindingTypeChanged(type);
     }
 }
 
diff --git a/src/render/materialsystem/qparametermapping.h b/src/render/materialsystem/qparametermapping.h
index 0e913a1b1..eb8a258f4 100644
--- a/src/render/materialsystem/qparametermapping.h
+++ b/src/render/materialsystem/qparametermapping.h
@@ -68,18 +68,19 @@ public:
     QParameterMapping(const QString &parameterName, const QString &shaderParameterName, QParameterMapping::Binding bindingType, Qt3DCore::QNode *parent = 0);
     ~QParameterMapping();
 
-    void setParameterName(const QString &name);
-    void setShaderVariableName(const QString &name);
-    void setBindingType(Binding type);
-
     QString parameterName() const;
     QString shaderVariableName() const;
     Binding bindingType() const;
 
+public Q_SLOTS:
+    void setParameterName(const QString &name);
+    void setShaderVariableName(const QString &name);
+    void setBindingType(Binding type);
+
 Q_SIGNALS:
-    void parameterNameChanged();
-    void shaderVariableNameChanged();
-    void bindingTypeChanged();
+    void parameterNameChanged(const QString &parameterName);
+    void shaderVariableNameChanged(const QString &shaderVariableName);
+    void bindingTypeChanged(Binding bindingType);
 
 protected:
     QParameterMapping(QParameterMappingPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/materialsystem/qrenderpass.cpp b/src/render/materialsystem/qrenderpass.cpp
index b7d07f88f..253b6d8bf 100644
--- a/src/render/materialsystem/qrenderpass.cpp
+++ b/src/render/materialsystem/qrenderpass.cpp
@@ -120,7 +120,7 @@ void QRenderPass::setShaderProgram(QShaderProgram *shaderProgram)
         }
 
         d->m_shader = shaderProgram;
-        emit shaderProgramChanged();
+        emit shaderProgramChanged(shaderProgram);
 
         // We need to add it as a child of the current node if it has been declared inline
         // Or not previously added as a child of the current node so that
diff --git a/src/render/materialsystem/qrenderpass.h b/src/render/materialsystem/qrenderpass.h
index 569ae8377..e1622ba7f 100644
--- a/src/render/materialsystem/qrenderpass.h
+++ b/src/render/materialsystem/qrenderpass.h
@@ -72,7 +72,6 @@ public:
     ParameterList attributes() const;
     ParameterList uniforms() const;
 
-    void setShaderProgram(QShaderProgram *shaderProgram);
     QShaderProgram *shaderProgram() const;
 
     void addAnnotation(QAnnotation *criterion);
@@ -91,8 +90,11 @@ public:
     void removeParameter(QParameter *p);
     QList<QParameter *> parameters() const;
 
+public Q_SLOTS:
+    void setShaderProgram(QShaderProgram *shaderProgram);
+
 Q_SIGNALS:
-    void shaderProgramChanged();
+    void shaderProgramChanged(QShaderProgram *shaderProgram);
 
 protected:
     QRenderPass(QRenderPassPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/materialsystem/qshaderprogram.cpp b/src/render/materialsystem/qshaderprogram.cpp
index 51faac661..590572f93 100644
--- a/src/render/materialsystem/qshaderprogram.cpp
+++ b/src/render/materialsystem/qshaderprogram.cpp
@@ -93,7 +93,7 @@ void QShaderProgram::setVertexShaderCode(const QByteArray &vertexShaderCode)
     Q_D(QShaderProgram);
     if (vertexShaderCode != d->m_vertexShaderCode) {
         d->m_vertexShaderCode = vertexShaderCode;
-        emit vertexShaderCodeChanged();
+        emit vertexShaderCodeChanged(vertexShaderCode);
     }
 }
 
@@ -108,7 +108,7 @@ void QShaderProgram::setTessellationControlShaderCode(const QByteArray &tessella
     Q_D(QShaderProgram);
     if (tessellationControlShaderCode != d->m_tessControlShaderCode) {
         d->m_tessControlShaderCode = tessellationControlShaderCode;
-        emit tessellationControlShaderCodeChanged();
+        emit tessellationControlShaderCodeChanged(tessellationControlShaderCode);
     }
 }
 
@@ -123,7 +123,7 @@ void QShaderProgram::setTessellationEvaluationShaderCode(const QByteArray &tesse
     Q_D(QShaderProgram);
     if (tessellationEvaluationShaderCode != d->m_tessEvalShaderCode) {
         d->m_tessEvalShaderCode = tessellationEvaluationShaderCode;
-        emit tessellationEvaluationShaderCodeChanged();
+        emit tessellationEvaluationShaderCodeChanged(tessellationEvaluationShaderCode);
     }
 }
 
@@ -138,7 +138,7 @@ void QShaderProgram::setGeometryShaderCode(const QByteArray &geometryShaderCode)
     Q_D(QShaderProgram);
     if (geometryShaderCode != d->m_geometryShaderCode) {
         d->m_geometryShaderCode = geometryShaderCode;
-        emit geometryShaderCodeChanged();
+        emit geometryShaderCodeChanged(geometryShaderCode);
     }
 }
 
@@ -156,7 +156,7 @@ void QShaderProgram::setFragmentShaderCode(const QByteArray &fragmentShaderCode)
     Q_D(QShaderProgram);
     if (fragmentShaderCode != d->m_fragmentShaderCode) {
         d->m_fragmentShaderCode = fragmentShaderCode;
-        emit fragmentShaderCodeChanged();
+        emit fragmentShaderCodeChanged(fragmentShaderCode);
     }
 }
 
@@ -171,7 +171,7 @@ void QShaderProgram::setComputeShaderCode(const QByteArray &computeShaderCode)
     Q_D(QShaderProgram);
     if (computeShaderCode != d->m_computeShaderCode) {
         d->m_computeShaderCode = computeShaderCode;
-        emit computeShaderCodeChanged();
+        emit computeShaderCodeChanged(computeShaderCode);
     }
 }
 
diff --git a/src/render/materialsystem/qshaderprogram.h b/src/render/materialsystem/qshaderprogram.h
index 7b286802c..1a1314156 100644
--- a/src/render/materialsystem/qshaderprogram.h
+++ b/src/render/materialsystem/qshaderprogram.h
@@ -71,22 +71,11 @@ public:
     Q_ENUM(ShaderType)
 
     // Source code in-line
-    void setVertexShaderCode(const QByteArray &vertexShaderCode);
     QByteArray vertexShaderCode() const;
-
-    void setTessellationControlShaderCode(const QByteArray &tessellationControlShaderCode);
     QByteArray tessellationControlShaderCode() const;
-
-    void setTessellationEvaluationShaderCode(const QByteArray &tessellationEvaluationShaderCode);
     QByteArray tessellationEvaluationShaderCode() const;
-
-    void setGeometryShaderCode(const QByteArray &geometryShaderCode);
     QByteArray geometryShaderCode() const;
-
-    void setFragmentShaderCode(const QByteArray &fragmentShaderCode);
     QByteArray fragmentShaderCode() const;
-
-    void setComputeShaderCode(const QByteArray &computeShaderCode);
     QByteArray computeShaderCode() const;
 
     void setShaderCode(ShaderType type, const QByteArray &shaderCode);
@@ -94,13 +83,21 @@ public:
 
     Q_INVOKABLE static QByteArray loadSource(const QUrl &sourceUrl);
 
+public Q_SLOTS:
+    void setVertexShaderCode(const QByteArray &vertexShaderCode);
+    void setTessellationControlShaderCode(const QByteArray &tessellationControlShaderCode);
+    void setTessellationEvaluationShaderCode(const QByteArray &tessellationEvaluationShaderCode);
+    void setGeometryShaderCode(const QByteArray &geometryShaderCode);
+    void setFragmentShaderCode(const QByteArray &fragmentShaderCode);
+    void setComputeShaderCode(const QByteArray &computeShaderCode);
+
 Q_SIGNALS:
-    void vertexShaderCodeChanged();
-    void tessellationControlShaderCodeChanged();
-    void tessellationEvaluationShaderCodeChanged();
-    void geometryShaderCodeChanged();
-    void fragmentShaderCodeChanged();
-    void computeShaderCodeChanged();
+    void vertexShaderCodeChanged(const QByteArray &vertexShaderCode);
+    void tessellationControlShaderCodeChanged(const QByteArray &tessellationControlShaderCode);
+    void tessellationEvaluationShaderCodeChanged(const QByteArray &tessellationEvaluationShaderCode);
+    void geometryShaderCodeChanged(const QByteArray &geometryShaderCode);
+    void fragmentShaderCodeChanged(const QByteArray &fragmentShaderCode);
+    void computeShaderCodeChanged(const QByteArray &computeShaderCode);
 
 protected:
     QShaderProgram(QShaderProgramPrivate &dd, Qt3DCore::QNode *parent = 0);
diff --git a/src/render/picking/qobjectpicker.cpp b/src/render/picking/qobjectpicker.cpp
index 6213c6d0b..96b3bb9f6 100644
--- a/src/render/picking/qobjectpicker.cpp
+++ b/src/render/picking/qobjectpicker.cpp
@@ -128,7 +128,7 @@ void QObjectPicker::setHoverEnabled(bool hoverEnabled)
     Q_D(QObjectPicker);
     if (hoverEnabled != d->m_hoverEnabled) {
         d->m_hoverEnabled = hoverEnabled;
-        emit hoverEnabledChanged();
+        emit hoverEnabledChanged(hoverEnabled);
     }
 }
 
@@ -199,7 +199,7 @@ void QObjectPicker::setPressed(bool pressed)
     if (d->m_pressed != pressed) {
         const bool blocked = blockNotifications(true);
         d->m_pressed = pressed;
-        emit pressedChanged();
+        emit pressedChanged(pressed);
         blockNotifications(blocked);
     }
 }
@@ -210,7 +210,7 @@ void QObjectPicker::setContainsMouse(bool containsMouse)
     if (d->m_containsMouse != containsMouse) {
         const bool blocked = blockNotifications(true);
         d->m_containsMouse = containsMouse;
-        emit containsMouseChanged();
+        emit containsMouseChanged(containsMouse);
         blockNotifications(blocked);
     }
 }
diff --git a/src/render/picking/qobjectpicker.h b/src/render/picking/qobjectpicker.h
index 81126796f..b64fb2694 100644
--- a/src/render/picking/qobjectpicker.h
+++ b/src/render/picking/qobjectpicker.h
@@ -59,21 +59,23 @@ public:
     explicit QObjectPicker(QNode *parent = Q_NULLPTR);
     ~QObjectPicker();
 
-    void setHoverEnabled(bool hoverEnabled);
     bool hoverEnabled() const;
 
     bool containsMouse() const;
     bool isPressed() const;
 
+public Q_SLOTS:
+    void setHoverEnabled(bool hoverEnabled);
+
 Q_SIGNALS:
     void pressed(Qt3DRender::QPickEvent *event);
     void released(Qt3DRender::QPickEvent *event);
     void clicked(Qt3DRender::QPickEvent *event);
     void entered();
     void exited();
-    void hoverEnabledChanged();
-    void pressedChanged();
-    void containsMouseChanged();
+    void hoverEnabledChanged(bool hoverEnabled);
+    void pressedChanged(bool pressed);
+    void containsMouseChanged(bool containsMouse);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/picking/qpickevent.cpp b/src/render/picking/qpickevent.cpp
index b2f7179b1..e90bc24c0 100644
--- a/src/render/picking/qpickevent.cpp
+++ b/src/render/picking/qpickevent.cpp
@@ -73,7 +73,7 @@ void QPickEvent::setAccepted(bool accepted)
     Q_D(QPickEvent);
     if (accepted != d->m_accepted) {
         d->m_accepted = accepted;
-        emit acceptedChanged();
+        emit acceptedChanged(accepted);
     }
 }
 
diff --git a/src/render/picking/qpickevent.h b/src/render/picking/qpickevent.h
index 5a9408516..793377ad8 100644
--- a/src/render/picking/qpickevent.h
+++ b/src/render/picking/qpickevent.h
@@ -55,10 +55,12 @@ public:
     ~QPickEvent();
 
     bool isAccepted() const;
+
+public Q_SLOTS:
     void setAccepted(bool accepted);
 
 Q_SIGNALS:
-    void acceptedChanged();
+    void acceptedChanged(bool accepted);
 
 private:
     Q_DECLARE_PRIVATE(QPickEvent)
diff --git a/src/render/renderstates/qalphatest.cpp b/src/render/renderstates/qalphatest.cpp
index 34071c52d..def17affe 100644
--- a/src/render/renderstates/qalphatest.cpp
+++ b/src/render/renderstates/qalphatest.cpp
@@ -88,7 +88,7 @@ void QAlphaTest::setFunc(QAlphaTest::AlphaFunc func)
     Q_D(QAlphaTest);
     if (d->m_func != func) {
         d->m_func = func;
-        emit funcChanged();
+        emit funcChanged(func);
     }
 }
 
@@ -103,7 +103,7 @@ void QAlphaTest::setClamp(float clamp)
     Q_D(QAlphaTest);
     if (d->m_clamp != clamp) {
         d->m_clamp = clamp;
-        emit clampChanged();
+        emit clampChanged(clamp);
     }
 }
 
diff --git a/src/render/renderstates/qalphatest.h b/src/render/renderstates/qalphatest.h
index b5def41ac..7465e18c3 100644
--- a/src/render/renderstates/qalphatest.h
+++ b/src/render/renderstates/qalphatest.h
@@ -69,14 +69,15 @@ public:
     ~QAlphaTest();
 
     AlphaFunc func() const;
-    void setFunc(AlphaFunc func);
-
     float clamp() const;
+
+public Q_SLOTS:
+    void setFunc(AlphaFunc func);
     void setClamp(float clamp);
 
 Q_SIGNALS:
-    void funcChanged();
-    void clampChanged();
+    void funcChanged(AlphaFunc func);
+    void clampChanged(float clamp);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qblendequation.cpp b/src/render/renderstates/qblendequation.cpp
index 85a1ad83c..02b3c682e 100644
--- a/src/render/renderstates/qblendequation.cpp
+++ b/src/render/renderstates/qblendequation.cpp
@@ -85,7 +85,7 @@ void QBlendEquation::setMode(QBlendEquation::BlendMode mode)
     Q_D(QBlendEquation);
     if (d->m_mode != mode) {
         d->m_mode = mode;
-        emit modeChanged();
+        emit modeChanged(mode);
     }
 }
 
diff --git a/src/render/renderstates/qblendequation.h b/src/render/renderstates/qblendequation.h
index a314a67b9..f5e58d1fe 100644
--- a/src/render/renderstates/qblendequation.h
+++ b/src/render/renderstates/qblendequation.h
@@ -66,10 +66,12 @@ public:
     ~QBlendEquation();
 
     BlendMode mode() const;
+
+public Q_SLOTS:
     void setMode(BlendMode mode);
 
 Q_SIGNALS:
-    void modeChanged();
+    void modeChanged(BlendMode mode);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qblendstate.cpp b/src/render/renderstates/qblendstate.cpp
index bc75aa3ce..0a27c5b35 100644
--- a/src/render/renderstates/qblendstate.cpp
+++ b/src/render/renderstates/qblendstate.cpp
@@ -159,7 +159,7 @@ void QBlendState::setSrcRGB(QBlendState::Blending srcRGB)
     Q_D(QBlendState);
     if (d->m_srcRGB != srcRGB) {
         d->m_srcRGB = srcRGB;
-        emit srcRGBChanged();
+        emit srcRGBChanged(srcRGB);
     }
 }
 
@@ -183,7 +183,7 @@ void QBlendState::setDstRGB(QBlendState::Blending dstRGB)
     Q_D(QBlendState);
     if (d->m_dstRGB != dstRGB) {
         d->m_dstRGB = dstRGB;
-        emit dstRGBChanged();
+        emit dstRGBChanged(dstRGB);
     }
 }
 
@@ -207,7 +207,7 @@ void QBlendState::setSrcAlpha(QBlendState::Blending srcAlpha)
     Q_D(QBlendState);
     if (d->m_srcAlpha != srcAlpha) {
         d->m_srcAlpha = srcAlpha;
-        emit srcAlphaChanged();
+        emit srcAlphaChanged(srcAlpha);
     }
 }
 
@@ -231,7 +231,7 @@ void QBlendState::setDstAlpha(QBlendState::Blending dstAlpha)
     Q_D(QBlendState);
     if (d->m_dstAlpha != dstAlpha) {
         d->m_dstAlpha = dstAlpha;
-        emit dstAlphaChanged();
+        emit dstAlphaChanged(dstAlpha);
     }
 }
 
diff --git a/src/render/renderstates/qblendstate.h b/src/render/renderstates/qblendstate.h
index f67b30275..5d9d53787 100644
--- a/src/render/renderstates/qblendstate.h
+++ b/src/render/renderstates/qblendstate.h
@@ -84,22 +84,21 @@ public:
     ~QBlendState();
 
     Blending srcRGB() const;
-    void setSrcRGB(Blending srcRGB);
-
     Blending dstRGB() const;
-    void setDstRGB(Blending dstRGB);
-
     Blending srcAlpha() const;
-    void setSrcAlpha(Blending srcAlpha);
-
     Blending dstAlpha() const;
+
+public Q_SLOTS:
+    void setSrcRGB(Blending srcRGB);
+    void setDstRGB(Blending dstRGB);
+    void setSrcAlpha(Blending srcAlpha);
     void setDstAlpha(Blending dstAlpha);
 
 Q_SIGNALS:
-    void srcRGBChanged();
-    void srcAlphaChanged();
-    void dstRGBChanged();
-    void dstAlphaChanged();
+    void srcRGBChanged(Blending srcRGB);
+    void srcAlphaChanged(Blending srcAlpha);
+    void dstRGBChanged(Blending dstRGB);
+    void dstAlphaChanged(Blending dstAlpha);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qclipplane.cpp b/src/render/renderstates/qclipplane.cpp
index 94f2572fd..999a249fe 100644
--- a/src/render/renderstates/qclipplane.cpp
+++ b/src/render/renderstates/qclipplane.cpp
@@ -109,7 +109,7 @@ void QClipPlane::setPlane(int plane)
     Q_D(QClipPlane);
     if (plane != d->m_plane) {
         d->m_plane = plane;
-        Q_EMIT planeChanged();
+        Q_EMIT planeChanged(plane);
     }
 }
 
diff --git a/src/render/renderstates/qclipplane.h b/src/render/renderstates/qclipplane.h
index b04661d85..73874a091 100644
--- a/src/render/renderstates/qclipplane.h
+++ b/src/render/renderstates/qclipplane.h
@@ -54,13 +54,15 @@ public:
     ~QClipPlane();
 
     int plane() const;
+
+public Q_SLOTS:
     void setPlane(int);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_FINAL;
 
 Q_SIGNALS:
-    void planeChanged();
+    void planeChanged(int plane);
 
 private:
     Q_DECLARE_PRIVATE(QClipPlane)
diff --git a/src/render/renderstates/qcolormask.cpp b/src/render/renderstates/qcolormask.cpp
index 4c9fabd78..e4b4e4db4 100644
--- a/src/render/renderstates/qcolormask.cpp
+++ b/src/render/renderstates/qcolormask.cpp
@@ -120,7 +120,7 @@ void QColorMask::setRed(bool red)
     Q_D(QColorMask);
     if (red != d->m_red) {
         d->m_red = red;
-        emit redChanged();
+        emit redChanged(red);
     }
 }
 
@@ -133,7 +133,7 @@ void QColorMask::setGreen(bool green)
     Q_D(QColorMask);
     if (green != d->m_green) {
         d->m_green = green;
-        emit greenChanged();
+        emit greenChanged(green);
     }
 }
 
@@ -146,7 +146,7 @@ void QColorMask::setBlue(bool blue)
     Q_D(QColorMask);
     if (blue != d->m_blue) {
         d->m_blue = blue;
-        emit blueChanged();
+        emit blueChanged(blue);
     }
 }
 
@@ -159,7 +159,7 @@ void QColorMask::setAlpha(bool alpha)
     Q_D(QColorMask);
     if (alpha != d->m_alpha) {
         d->m_alpha = alpha;
-        emit alphaChanged();
+        emit alphaChanged(alpha);
     }
 }
 
diff --git a/src/render/renderstates/qcolormask.h b/src/render/renderstates/qcolormask.h
index 2e5aefe9c..5677c8308 100644
--- a/src/render/renderstates/qcolormask.h
+++ b/src/render/renderstates/qcolormask.h
@@ -62,16 +62,17 @@ public:
     bool isBlue() const;
     bool isAlpha() const;
 
+public Q_SLOTS:
     void setRed(bool red);
     void setGreen(bool green);
     void setBlue(bool blue);
     void setAlpha(bool alpha);
 
 Q_SIGNALS:
-    void redChanged();
-    void greenChanged();
-    void blueChanged();
-    void alphaChanged();
+    void redChanged(bool red);
+    void greenChanged(bool green);
+    void blueChanged(bool blue);
+    void alphaChanged(bool alpha);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_FINAL;
diff --git a/src/render/renderstates/qcullface.cpp b/src/render/renderstates/qcullface.cpp
index ce71aaa59..c255ce94a 100644
--- a/src/render/renderstates/qcullface.cpp
+++ b/src/render/renderstates/qcullface.cpp
@@ -85,7 +85,7 @@ void QCullFace::setMode(QCullFace::CullingMode mode)
     Q_D(QCullFace);
     if (d->m_mode != mode) {
         d->m_mode = mode;
-        emit modeChanged();
+        emit modeChanged(mode);
     }
 }
 
diff --git a/src/render/renderstates/qcullface.h b/src/render/renderstates/qcullface.h
index 9cbfe53fa..316fac7a4 100644
--- a/src/render/renderstates/qcullface.h
+++ b/src/render/renderstates/qcullface.h
@@ -66,10 +66,12 @@ public:
     ~QCullFace();
 
     CullingMode mode() const;
+
+public Q_SLOTS:
     void setMode(CullingMode mode);
 
 Q_SIGNALS:
-    void modeChanged();
+    void modeChanged(CullingMode mode);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qdepthmask.cpp b/src/render/renderstates/qdepthmask.cpp
index 76e5339d0..fbf6e4750 100644
--- a/src/render/renderstates/qdepthmask.cpp
+++ b/src/render/renderstates/qdepthmask.cpp
@@ -85,7 +85,7 @@ void QDepthMask::setMask(bool mask)
     Q_D(QDepthMask);
     if (d->m_mask != mask) {
         d->m_mask = mask;
-        emit maskChanged();
+        emit maskChanged(mask);
     }
 }
 
diff --git a/src/render/renderstates/qdepthmask.h b/src/render/renderstates/qdepthmask.h
index acee32b9d..816da9038 100644
--- a/src/render/renderstates/qdepthmask.h
+++ b/src/render/renderstates/qdepthmask.h
@@ -55,10 +55,12 @@ public:
     ~QDepthMask();
 
     bool mask() const;
+
+public Q_SLOTS:
     void setMask(bool mask);
 
 Q_SIGNALS:
-    void maskChanged();
+    void maskChanged(bool mask);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qdepthtest.cpp b/src/render/renderstates/qdepthtest.cpp
index 017b7ce00..74287d2eb 100644
--- a/src/render/renderstates/qdepthtest.cpp
+++ b/src/render/renderstates/qdepthtest.cpp
@@ -87,7 +87,7 @@ void QDepthTest::setFunc(QDepthTest::DepthFunc func)
     Q_D(QDepthTest);
     if (d->m_func != func) {
         d->m_func = func;
-        emit funcChanged();
+        emit funcChanged(func);
     }
 }
 
diff --git a/src/render/renderstates/qdepthtest.h b/src/render/renderstates/qdepthtest.h
index 5e8da269b..f70ff1d59 100644
--- a/src/render/renderstates/qdepthtest.h
+++ b/src/render/renderstates/qdepthtest.h
@@ -68,10 +68,12 @@ public:
     ~QDepthTest();
 
     DepthFunc func() const;
+
+public Q_SLOTS:
     void setFunc(DepthFunc func);
 
 Q_SIGNALS:
-    void funcChanged();
+    void funcChanged(DepthFunc func);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qfrontface.cpp b/src/render/renderstates/qfrontface.cpp
index 4ec5043a4..fc11fa167 100644
--- a/src/render/renderstates/qfrontface.cpp
+++ b/src/render/renderstates/qfrontface.cpp
@@ -85,7 +85,7 @@ void QFrontFace::setDirection(QFrontFace::FaceDir direction)
     Q_D(QFrontFace);
     if (d->m_direction != direction) {
         d->m_direction = direction;
-        emit directionChanged();
+        emit directionChanged(direction);
     }
 }
 
diff --git a/src/render/renderstates/qfrontface.h b/src/render/renderstates/qfrontface.h
index fefc142b8..d0bc852e2 100644
--- a/src/render/renderstates/qfrontface.h
+++ b/src/render/renderstates/qfrontface.h
@@ -63,10 +63,12 @@ public:
     ~QFrontFace();
 
     FaceDir direction() const;
+
+public Q_SLOTS:
     void setDirection(FaceDir direction);
 
 Q_SIGNALS:
-    void directionChanged();
+    void directionChanged(FaceDir direction);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qpolygonoffset.h b/src/render/renderstates/qpolygonoffset.h
index acc93dd54..7065d2cfb 100644
--- a/src/render/renderstates/qpolygonoffset.h
+++ b/src/render/renderstates/qpolygonoffset.h
@@ -56,14 +56,15 @@ public:
     ~QPolygonOffset();
 
     float factor() const;
-    void setFactor(float factor);
-
     float units() const;
+
+public Q_SLOTS:
+    void setFactor(float factor);
     void setUnits(float units);
 
 Q_SIGNALS:
-    void factorChanged(float newFactor);
-    void unitsChanged(float newUnits);
+    void factorChanged(float factor);
+    void unitsChanged(float units);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qscissortest.cpp b/src/render/renderstates/qscissortest.cpp
index cc2624f41..d74896501 100644
--- a/src/render/renderstates/qscissortest.cpp
+++ b/src/render/renderstates/qscissortest.cpp
@@ -95,7 +95,7 @@ void QScissorTest::setLeft(int left)
     Q_D(QScissorTest);
     if (d->m_left != left) {
         d->m_left = left;
-        emit leftChanged();
+        emit leftChanged(left);
     }
 }
 
@@ -110,7 +110,7 @@ void QScissorTest::setBottom(int bottom)
     Q_D(QScissorTest);
     if (d->m_bottom != bottom) {
         d->m_bottom = bottom;
-        emit bottomChanged();
+        emit bottomChanged(bottom);
     }
 }
 
@@ -125,7 +125,7 @@ void QScissorTest::setWidth(int width)
     Q_D(QScissorTest);
     if (d->m_width != width) {
         d->m_width = width;
-        emit widthChanged();
+        emit widthChanged(width);
     }
 }
 
@@ -140,7 +140,7 @@ void QScissorTest::setHeight(int height)
     Q_D(QScissorTest);
     if (d->m_height != height) {
         d->m_height = height;
-        emit heightChanged();
+        emit heightChanged(height);
     }
 }
 
diff --git a/src/render/renderstates/qscissortest.h b/src/render/renderstates/qscissortest.h
index 41e843ea3..9dd69592c 100644
--- a/src/render/renderstates/qscissortest.h
+++ b/src/render/renderstates/qscissortest.h
@@ -59,22 +59,21 @@ public:
     ~QScissorTest();
 
     int left() const;
-    void setLeft(int left);
-
     int bottom() const;
-    void setBottom(int bottom);
-
     int width() const;
-    void setWidth(int width);
-
     int height() const;
+
+public Q_SLOTS:
+    void setLeft(int left);
+    void setBottom(int bottom);
+    void setWidth(int width);
     void setHeight(int height);
 
 Q_SIGNALS:
-    void leftChanged();
-    void bottomChanged();
-    void widthChanged();
-    void heightChanged();
+    void leftChanged(int left);
+    void bottomChanged(int bottom);
+    void widthChanged(int width);
+    void heightChanged(int height);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/renderstates/qstencilmask.cpp b/src/render/renderstates/qstencilmask.cpp
index 32d47a54b..066bec2c3 100644
--- a/src/render/renderstates/qstencilmask.cpp
+++ b/src/render/renderstates/qstencilmask.cpp
@@ -73,7 +73,7 @@ void QStencilMask::setFrontMask(uint mask)
     Q_D(QStencilMask);
     if (d->m_frontMask != mask) {
         d->m_frontMask = mask;
-        Q_EMIT frontMaskChanged();
+        Q_EMIT frontMaskChanged(mask);
     }
 }
 
@@ -82,7 +82,7 @@ void QStencilMask::setBackMask(uint mask)
     Q_D(QStencilMask);
     if (d->m_backMask != mask) {
         d->m_backMask = mask;
-        Q_EMIT backMaskChanged();
+        Q_EMIT backMaskChanged(mask);
     }
 }
 
diff --git a/src/render/renderstates/qstencilmask.h b/src/render/renderstates/qstencilmask.h
index 5be51f5c1..364e34a59 100644
--- a/src/render/renderstates/qstencilmask.h
+++ b/src/render/renderstates/qstencilmask.h
@@ -54,14 +54,16 @@ public:
     explicit QStencilMask(Qt3DCore::QNode *parent = 0);
     ~QStencilMask();
 
-    void setFrontMask(uint mask);
     uint frontMask() const;
-    void setBackMask(uint mask);
     uint backMask() const;
 
+public Q_SLOTS:
+    void setFrontMask(uint mask);
+    void setBackMask(uint mask);
+
 Q_SIGNALS:
-    void frontMaskChanged();
-    void backMaskChanged();
+    void frontMaskChanged(uint frontMask);
+    void backMaskChanged(uint backMask);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_FINAL;
diff --git a/src/render/renderstates/qstencilopseparate.cpp b/src/render/renderstates/qstencilopseparate.cpp
index ec2c4e40c..3451476e6 100644
--- a/src/render/renderstates/qstencilopseparate.cpp
+++ b/src/render/renderstates/qstencilopseparate.cpp
@@ -80,7 +80,7 @@ void QStencilOpSeparate::setStencilFail(QStencilOpSeparate::StencilOp op)
     Q_D(QStencilOpSeparate);
     if (d->m_stencilFailOp != op) {
         d->m_stencilFailOp = op;
-        Q_EMIT stencilFailChanged();
+        Q_EMIT stencilFailChanged(op);
     }
 }
 
@@ -95,7 +95,7 @@ void QStencilOpSeparate::setDepthFail(QStencilOpSeparate::StencilOp op)
     Q_D(QStencilOpSeparate);
     if (d->m_depthFailOp != op) {
         d->m_depthFailOp = op;
-        Q_EMIT depthFailChanged();
+        Q_EMIT depthFailChanged(op);
     }
 }
 
@@ -110,7 +110,7 @@ void QStencilOpSeparate::setStencilDepthPass(QStencilOpSeparate::StencilOp op)
     Q_D(QStencilOpSeparate);
     if (d->m_stencilDepthPassOp != op) {
         d->m_stencilDepthPassOp = op;
-        Q_EMIT stencilDepthPassChanged();
+        Q_EMIT stencilDepthPassChanged(op);
     }
 }
 
diff --git a/src/render/renderstates/qstencilopseparate.h b/src/render/renderstates/qstencilopseparate.h
index cc21ebaad..6b82b7c9e 100644
--- a/src/render/renderstates/qstencilopseparate.h
+++ b/src/render/renderstates/qstencilopseparate.h
@@ -81,20 +81,20 @@ public:
 
     StencilFaceMode faceMode() const;
 
-    void setStencilFail(StencilOp op);
     StencilOp stencilFail() const;
-
-    void setDepthFail(StencilOp op);
     StencilOp depthFail() const;
+    StencilOp stencilDepthPass() const;
 
+public Q_SLOTS:
+    void setStencilFail(StencilOp op);
+    void setDepthFail(StencilOp op);
     void setStencilDepthPass(StencilOp op);
-    StencilOp stencilDepthPass() const;
 
 Q_SIGNALS:
-    void stencilFailChanged();
-    void depthFailChanged();
-    void stencilDepthPassChanged();
-    void faceModeChanged();
+    void stencilFailChanged(StencilOp stencilFail);
+    void depthFailChanged(StencilOp depthFail);
+    void stencilDepthPassChanged(StencilOp stencilDepthPass);
+    void faceModeChanged(StencilFaceMode faceMode);
 
 private:
     explicit QStencilOpSeparate(StencilFaceMode mode, QObject *parent = 0);
diff --git a/src/render/renderstates/qstenciltestseparate.cpp b/src/render/renderstates/qstenciltestseparate.cpp
index 87b9fc798..a109d1338 100644
--- a/src/render/renderstates/qstenciltestseparate.cpp
+++ b/src/render/renderstates/qstenciltestseparate.cpp
@@ -81,7 +81,7 @@ void QStencilTestSeparate::setMask(uint mask)
     Q_D(QStencilTestSeparate);
     if (d->m_mask != mask) {
         d->m_mask = mask;
-        emit maskChanged();
+        emit maskChanged(mask);
     }
 }
 
@@ -96,7 +96,7 @@ void QStencilTestSeparate::setRef(int ref)
     Q_D(QStencilTestSeparate);
     if (d->m_ref != ref) {
         d->m_ref = ref;
-        emit refChanged();
+        emit refChanged(ref);
     }
 }
 
@@ -111,7 +111,7 @@ void QStencilTestSeparate::setFunc(QStencilTestSeparate::StencilFunc func)
     Q_D(QStencilTestSeparate);
     if (d->m_func != func) {
         d->m_func = func;
-        emit funcChanged();
+        emit funcChanged(func);
     }
 }
 
diff --git a/src/render/renderstates/qstenciltestseparate.h b/src/render/renderstates/qstenciltestseparate.h
index 79258689d..21a9e1d31 100644
--- a/src/render/renderstates/qstenciltestseparate.h
+++ b/src/render/renderstates/qstenciltestseparate.h
@@ -80,21 +80,21 @@ public:
     ~QStencilTestSeparate();
 
     uint mask() const;
-    void setMask(uint mask);
-
     int ref() const;
-    void setRef(int ref);
-
     StencilFunc func() const;
-    void setFunc(StencilFunc func);
 
     StencilFaceMode faceMode() const;
 
+public Q_SLOTS:
+    void setMask(uint mask);
+    void setRef(int ref);
+    void setFunc(StencilFunc func);
+
 Q_SIGNALS:
-    void maskChanged();
-    void funcChanged();
-    void refChanged();
-    void faceModeChanged();
+    void maskChanged(uint mask);
+    void funcChanged(StencilFunc func);
+    void refChanged(int ref);
+    void faceModeChanged(StencilFaceMode faceMode);
 
 private:
     explicit QStencilTestSeparate(StencilFaceMode face, QObject *parent = 0);
diff --git a/src/render/texture/qabstracttextureimage.cpp b/src/render/texture/qabstracttextureimage.cpp
index ef3414e62..38e5ad267 100644
--- a/src/render/texture/qabstracttextureimage.cpp
+++ b/src/render/texture/qabstracttextureimage.cpp
@@ -166,7 +166,7 @@ void QAbstractTextureImage::setMipmapLevel(int level)
     Q_D(QAbstractTextureImage);
     if (level != d->m_mipmapLevel) {
         d->m_mipmapLevel = level;
-        emit mipmapLevelChanged();
+        emit mipmapLevelChanged(level);
     }
 }
 
@@ -175,7 +175,7 @@ void QAbstractTextureImage::setLayer(int layer)
     Q_D(QAbstractTextureImage);
     if (layer != d->m_layer) {
         d->m_layer = layer;
-        emit layerChanged();
+        emit layerChanged(layer);
     }
 }
 
@@ -184,7 +184,7 @@ void QAbstractTextureImage::setCubeMapFace(QAbstractTextureProvider::CubeMapFace
     Q_D(QAbstractTextureImage);
     if (face != d->m_face) {
         d->m_face = face;
-        emit cubeMapFaceChanged();
+        emit cubeMapFaceChanged(face);
     }
 }
 
diff --git a/src/render/texture/qabstracttextureimage.h b/src/render/texture/qabstracttextureimage.h
index dee69c3a2..1a6ffc6de 100644
--- a/src/render/texture/qabstracttextureimage.h
+++ b/src/render/texture/qabstracttextureimage.h
@@ -74,17 +74,18 @@ public:
     int layer() const;
     QAbstractTextureProvider::CubeMapFace cubeMapFace() const;
 
+    void update();
+    virtual QTextureDataFunctorPtr dataFunctor() const = 0;
+
+public Q_SLOTS:
     void setMipmapLevel(int level);
     void setLayer(int layer);
     void setCubeMapFace(QAbstractTextureProvider::CubeMapFace face);
 
-    void update();
-    virtual QTextureDataFunctorPtr dataFunctor() const = 0;
-
 Q_SIGNALS:
-    void mipmapLevelChanged();
-    void layerChanged();
-    void cubeMapFaceChanged();
+    void mipmapLevelChanged(int mipmapLevel);
+    void layerChanged(int layer);
+    void cubeMapFaceChanged(QAbstractTextureProvider::CubeMapFace cubeMapFace);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/texture/qabstracttextureprovider.cpp b/src/render/texture/qabstracttextureprovider.cpp
index 2f91fd385..ca9849771 100644
--- a/src/render/texture/qabstracttextureprovider.cpp
+++ b/src/render/texture/qabstracttextureprovider.cpp
@@ -147,7 +147,7 @@ void QAbstractTextureProvider::setWidth(int width)
     Q_D(QAbstractTextureProvider);
     if (d->m_width != width) {
         d->m_width = width;
-        emit widthChanged();
+        emit widthChanged(width);
     }
 }
 
@@ -161,7 +161,7 @@ void QAbstractTextureProvider::setHeight(int height)
     Q_D(QAbstractTextureProvider);
     if (d->m_height != height) {
         d->m_height = height;
-        emit heightChanged();
+        emit heightChanged(height);
     }
 }
 
@@ -175,7 +175,7 @@ void QAbstractTextureProvider::setDepth(int depth)
     Q_D(QAbstractTextureProvider);
     if (d->m_depth != depth) {
         d->m_depth = depth;
-        emit depthChanged();
+        emit depthChanged(depth);
     }
 }
 
@@ -211,7 +211,7 @@ void QAbstractTextureProvider::setMaximumLayers(int maximumLayers)
     Q_D(QAbstractTextureProvider);
     if (d->m_maximumLayers != maximumLayers) {
         d->m_maximumLayers = maximumLayers;
-        emit maximumLayersChanged();
+        emit maximumLayersChanged(maximumLayers);
     }
 }
 
@@ -245,7 +245,7 @@ void QAbstractTextureProvider::setUnique(bool unique)
     Q_D(QAbstractTextureProvider);
     if (d->m_unique != unique) {
         d->m_unique = unique;
-        emit uniqueChanged();
+        emit uniqueChanged(unique);
     }
 }
 
@@ -270,7 +270,7 @@ void QAbstractTextureProvider::setFormat(TextureFormat format)
     Q_D(QAbstractTextureProvider);
     if (d->m_format != format) {
         d->m_format = format;
-        emit formatChanged();
+        emit formatChanged(format);
     }
 }
 
@@ -293,7 +293,7 @@ void QAbstractTextureProvider::setStatus(Status status)
     Q_D(QAbstractTextureProvider);
     if (status != d->m_status) {
         d->m_status = status;
-        emit statusChanged();
+        emit statusChanged(status);
     }
 }
 
@@ -382,7 +382,7 @@ void QAbstractTextureProvider::setGenerateMipMaps(bool gen)
     Q_D(QAbstractTextureProvider);
     if (d->m_autoMipMap != gen) {
         d->m_autoMipMap = gen;
-        emit generateMipMapsChanged();
+        emit generateMipMapsChanged(gen);
     }
 }
 
@@ -402,7 +402,7 @@ void QAbstractTextureProvider::setMinificationFilter(Filter f)
     Q_D(QAbstractTextureProvider);
     if (d->m_minFilter != f) {
         d->m_minFilter = f;
-        emit minificationFilterChanged();
+        emit minificationFilterChanged(f);
     }
 }
 
@@ -416,7 +416,7 @@ void QAbstractTextureProvider::setMagnificationFilter(Filter f)
     Q_D(QAbstractTextureProvider);
     if (d->m_magFilter != f) {
         d->m_magFilter = f;
-        emit magnificationFilterChanged();
+        emit magnificationFilterChanged(f);
     }
 }
 
@@ -479,7 +479,7 @@ void QAbstractTextureProvider::setMaximumAnisotropy(float anisotropy)
     Q_D(QAbstractTextureProvider);
     if (!qFuzzyCompare(d->m_maximumAnisotropy, anisotropy)) {
         d->m_maximumAnisotropy = anisotropy;
-        emit maximumAnisotropyChanged();
+        emit maximumAnisotropyChanged(anisotropy);
     }
 }
 
@@ -499,7 +499,7 @@ void QAbstractTextureProvider::setComparisonFunction(QAbstractTextureProvider::C
     Q_D(QAbstractTextureProvider);
     if (d->m_comparisonFunction != function) {
         d->m_comparisonFunction = function;
-        emit comparisonFunctionChanged();
+        emit comparisonFunctionChanged(function);
     }
 }
 
@@ -519,7 +519,7 @@ void QAbstractTextureProvider::setComparisonMode(QAbstractTextureProvider::Compa
     Q_D(QAbstractTextureProvider);
     if (d->m_comparisonMode != mode) {
         d->m_comparisonMode = mode;
-        emit comparisonModeChanged();
+        emit comparisonModeChanged(mode);
     }
 }
 
diff --git a/src/render/texture/qabstracttextureprovider.h b/src/render/texture/qabstracttextureprovider.h
index 1e9aa08c8..bd13b59ea 100644
--- a/src/render/texture/qabstracttextureprovider.h
+++ b/src/render/texture/qabstracttextureprovider.h
@@ -263,8 +263,8 @@ public:
 
     Target target() const;
 
-    void setFormat(TextureFormat format);
     TextureFormat format() const;
+    bool generateMipMaps() const;
 
     Status status() const;
 
@@ -272,58 +272,51 @@ public:
     void removeTextureImage(QAbstractTextureImage *textureImage);
     QList<QAbstractTextureImage *> textureImages() const;
 
-    void setGenerateMipMaps(bool gen);
-    bool generateMipMaps() const;
-
     // sampler data - in the future proxy to a Sampler helper
-    void setMinificationFilter(Filter f);
-    void setMagnificationFilter(Filter f);
-
-    Filter minificationFilter() const;
-    Filter magnificationFilter() const;
-
     void setWrapMode(const QTextureWrapMode &wrapMode);
     QTextureWrapMode *wrapMode();
 
-    void setMaximumAnisotropy(float anisotropy);
-    float maximumAnisotropy() const;
+    void setSize(int width, int height=1, int depth=1);
 
-    void setComparisonFunction(ComparisonFunction function);
+    Filter minificationFilter() const;
+    Filter magnificationFilter() const;
+    float maximumAnisotropy() const;
     ComparisonFunction comparisonFunction() const;
-
-    void setComparisonMode(ComparisonMode mode);
     ComparisonMode comparisonMode() const;
-
-    void setSize(int width, int height=1, int depth=1);
-
-    void setWidth(int width);
-    void setHeight(int height);
-    void setDepth(int depth);
-
     int width() const;
     int height() const;
     int depth() const;
-
-    void setMaximumLayers(int maximumLayers);
     int maximumLayers() const;
+    bool isUnique() const;
 
+public Q_SLOTS:
+    void setFormat(TextureFormat format);
+    void setGenerateMipMaps(bool gen);
+    void setWidth(int width);
+    void setHeight(int height);
+    void setDepth(int depth);
+    void setMinificationFilter(Filter f);
+    void setMagnificationFilter(Filter f);
+    void setMaximumAnisotropy(float anisotropy);
+    void setComparisonFunction(ComparisonFunction function);
+    void setComparisonMode(ComparisonMode mode);
+    void setMaximumLayers(int maximumLayers);
     void setUnique(bool unique);
-    bool isUnique() const;
 
 Q_SIGNALS:
-    void formatChanged();
-    void statusChanged();
-    void generateMipMapsChanged();
-    void widthChanged();
-    void heightChanged();
-    void depthChanged();
-    void magnificationFilterChanged();
-    void minificationFilterChanged();
-    void maximumAnisotropyChanged();
-    void comparisonFunctionChanged();
-    void comparisonModeChanged();
-    void maximumLayersChanged();
-    void uniqueChanged();
+    void formatChanged(TextureFormat format);
+    void statusChanged(Status status);
+    void generateMipMapsChanged(bool generateMipMaps);
+    void widthChanged(int width);
+    void heightChanged(int height);
+    void depthChanged(int depth);
+    void magnificationFilterChanged(Filter magnificationFilter);
+    void minificationFilterChanged(Filter minificationFilter);
+    void maximumAnisotropyChanged(float maximumAnisotropy);
+    void comparisonFunctionChanged(ComparisonFunction comparisonFunction);
+    void comparisonModeChanged(ComparisonMode comparisonMode);
+    void maximumLayersChanged(int maximumLayers);
+    void uniqueChanged(bool unique);
 
 protected:
     explicit QAbstractTextureProvider(Qt3DCore::QNode *parent = 0);
diff --git a/src/render/texture/qtextureimage.cpp b/src/render/texture/qtextureimage.cpp
index 761d26ae5..2fdf16469 100644
--- a/src/render/texture/qtextureimage.cpp
+++ b/src/render/texture/qtextureimage.cpp
@@ -165,7 +165,7 @@ void QTextureImage::setSource(const QUrl &source)
     Q_D(QTextureImage);
     if (source != d->m_source) {
         d->m_source = source;
-        emit sourceChanged();
+        emit sourceChanged(source);
         update();
     }
 }
diff --git a/src/render/texture/qtextureimage.h b/src/render/texture/qtextureimage.h
index 357cc9ebf..c3528a245 100644
--- a/src/render/texture/qtextureimage.h
+++ b/src/render/texture/qtextureimage.h
@@ -56,12 +56,14 @@ public:
     ~QTextureImage();
 
     QUrl source() const;
-    void setSource(const QUrl &source);
 
     QTextureDataFunctorPtr dataFunctor() const Q_DECL_OVERRIDE;
 
+public Q_SLOTS:
+    void setSource(const QUrl &source);
+
 Q_SIGNALS:
-    void sourceChanged();
+    void sourceChanged(const QUrl &source);
 
 protected:
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
diff --git a/src/render/texture/qwrapmode.cpp b/src/render/texture/qwrapmode.cpp
index 4baa6711b..abbd63261 100644
--- a/src/render/texture/qwrapmode.cpp
+++ b/src/render/texture/qwrapmode.cpp
@@ -95,7 +95,7 @@ void QTextureWrapMode::setX(WrapMode x)
     Q_D(QTextureWrapMode);
     if (d->m_x != x) {
         d->m_x = x;
-        emit xChanged();
+        emit xChanged(x);
     }
 }
 
@@ -117,7 +117,7 @@ void QTextureWrapMode::setY(WrapMode y)
     Q_D(QTextureWrapMode);
     if (d->m_y != y) {
         d->m_y = y;
-        emit yChanged();
+        emit yChanged(y);
     }
 }
 
@@ -139,7 +139,7 @@ void QTextureWrapMode::setZ(WrapMode z)
     Q_D(QTextureWrapMode);
     if (d->m_z != z) {
         d->m_z = z;
-        emit zChanged();
+        emit zChanged(z);
     }
 }
 
diff --git a/src/render/texture/qwrapmode.h b/src/render/texture/qwrapmode.h
index 4bd2cc1ff..40e6d5583 100644
--- a/src/render/texture/qwrapmode.h
+++ b/src/render/texture/qwrapmode.h
@@ -65,19 +65,19 @@ public:
     explicit QTextureWrapMode(WrapMode wrapMode = ClampToEdge, QObject *parent = 0);
     explicit QTextureWrapMode(WrapMode x, WrapMode y, WrapMode z, QObject *parent = 0);
 
-    void setX(WrapMode x);
     WrapMode x() const;
-
-    void setY(WrapMode y);
     WrapMode y() const;
+    WrapMode z() const;
 
+public Q_SLOTS:
+    void setX(WrapMode x);
+    void setY(WrapMode y);
     void setZ(WrapMode z);
-    WrapMode z() const;
 
 Q_SIGNALS:
-    void xChanged();
-    void yChanged();
-    void zChanged();
+    void xChanged(WrapMode x);
+    void yChanged(WrapMode y);
+    void zChanged(WrapMode z);
 
 private:
     Q_DECLARE_PRIVATE(QTextureWrapMode)