QPointLight property changes

Removed QVector3D attenuation
Added constantAttenuation
Added linearAttenuation
Added quadraticAttenuation

Change-Id: I0ee9081493a09ec7133fd47207f41b76d4abd9b5
Task-number: QTBUG-51490
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

4 files changed, 44 insertions, 45 deletions

diff --git a/src/render/lights/qpointlight.cpp b/src/render/lights/qpointlight.cpp
index 68db07ecc..57b276c6f 100644
--- a/src/render/lights/qpointlight.cpp
+++ b/src/render/lights/qpointlight.cpp
@@ -63,7 +63,9 @@ namespace Qt3DRender {
 
 QPointLightPrivate::QPointLightPrivate(QLight::Type type)
     : QLightPrivate(type)
-    , m_attenuation(0.0f, 0.0f, 0.002f)
+    , m_constantAttenuation(0.0f)
+    , m_linearAttenuation(0.0f)
+    , m_quadraticAttenuation(0.002f)
 {
 }
 
@@ -98,63 +100,48 @@ QPointLight::QPointLight(QPointLightPrivate &dd, QNode *parent)
 {
 }
 
-QVector3D QPointLight::attenuation() const
-{
-    Q_D(const QPointLight);
-    return d->m_attenuation;
-}
-
-void QPointLight::setAttenuation(const QVector3D &value)
-{
-    Q_D(QPointLight);
-    if (d->m_attenuation != value) {
-        d->m_attenuation = value;
-        emit attenuationChanged(value);
-    }
-}
-
 float QPointLight::constantAttenuation() const
 {
     Q_D(const QPointLight);
-    return d->m_attenuation.x();
+    return d->m_constantAttenuation;
 }
 
 void QPointLight::setConstantAttenuation(float value)
 {
     Q_D(QPointLight);
-    if (d->m_attenuation.x() != value) {
-        d->m_attenuation.setX(value);
-        emit attenuationChanged(d->m_attenuation);
+    if (d->m_constantAttenuation != value) {
+        d->m_constantAttenuation = value;
+        emit constantAttenuationChanged(value);
     }
 }
 
 float QPointLight::linearAttenuation() const
 {
     Q_D(const QPointLight);
-    return d->m_attenuation.y();
+    return d->m_linearAttenuation;
 }
 
 void QPointLight::setLinearAttenuation(float value)
 {
     Q_D(QPointLight);
-    if (d->m_attenuation.y() != value) {
-        d->m_attenuation.setY(value);
-        emit attenuationChanged(d->m_attenuation);
+    if (d->m_linearAttenuation != value) {
+        d->m_linearAttenuation = value;
+        emit linearAttenuationChanged(value);
     }
 }
 
 float QPointLight::quadraticAttenuation() const
 {
     Q_D(const QPointLight);
-    return d->m_attenuation.z();
+    return d->m_quadraticAttenuation;
 }
 
 void QPointLight::setQuadraticAttenuation(float value)
 {
     Q_D(QPointLight);
-    if (d->m_attenuation.z() != value) {
-        d->m_attenuation.setZ(value);
-        emit attenuationChanged(d->m_attenuation);
+    if (d->m_quadraticAttenuation != value) {
+        d->m_quadraticAttenuation = value;
+        emit quadraticAttenuationChanged(value);
     }
 }
 
diff --git a/src/render/lights/qpointlight.h b/src/render/lights/qpointlight.h
index 03cd169d0..054d9d7c1 100644
--- a/src/render/lights/qpointlight.h
+++ b/src/render/lights/qpointlight.h
@@ -51,27 +51,26 @@ class QPointLightPrivate;
 class QT3DRENDERSHARED_EXPORT QPointLight : public QLight
 {
     Q_OBJECT
-    Q_PROPERTY(QVector3D attenuation READ attenuation WRITE setAttenuation NOTIFY attenuationChanged)
+    Q_PROPERTY(float constantAttenuation READ constantAttenuation WRITE setConstantAttenuation NOTIFY constantAttenuationChanged)
+    Q_PROPERTY(float linearAttenuation READ linearAttenuation WRITE setLinearAttenuation NOTIFY linearAttenuationChanged)
+    Q_PROPERTY(float quadraticAttenuation READ quadraticAttenuation WRITE setQuadraticAttenuation NOTIFY quadraticAttenuationChanged)
 
 public:
     explicit QPointLight(Qt3DCore::QNode *parent = 0);
 
-    QVector3D attenuation() const;
-
     float constantAttenuation() const;
-    void setConstantAttenuation(float value);
-
     float linearAttenuation() const;
-    void setLinearAttenuation(float value);
-
     float quadraticAttenuation() const;
-    void setQuadraticAttenuation(float value);
 
 public Q_SLOTS:
-    void setAttenuation(const QVector3D &value);
+    void setConstantAttenuation(float value);
+    void setLinearAttenuation(float value);
+    void setQuadraticAttenuation(float value);
 
 Q_SIGNALS:
-    void attenuationChanged(const QVector3D &attenuation);
+    void constantAttenuationChanged(float constantAttenuation);
+    void linearAttenuationChanged(float linearAttenuation);
+    void quadraticAttenuationChanged(float quadraticAttenuation);
 
 protected:
     Q_DECLARE_PRIVATE(QPointLight)
diff --git a/src/render/lights/qpointlight_p.h b/src/render/lights/qpointlight_p.h
index 66838faf9..74f32910b 100644
--- a/src/render/lights/qpointlight_p.h
+++ b/src/render/lights/qpointlight_p.h
@@ -64,7 +64,9 @@ class QPointLightPrivate : public QLightPrivate
 public:
     QPointLightPrivate(QLight::Type type = QLight::PointLight);
 
-    QVector3D m_attenuation;
+    float m_constantAttenuation;
+    float m_linearAttenuation;
+    float m_quadraticAttenuation;
 
     Q_DECLARE_PUBLIC(QPointLight)
 };
diff --git a/tests/auto/render/qlight/tst_qlight.cpp b/tests/auto/render/qlight/tst_qlight.cpp
index 00ad8a6a0..c93198e2c 100644
--- a/tests/auto/render/qlight/tst_qlight.cpp
+++ b/tests/auto/render/qlight/tst_qlight.cpp
@@ -68,14 +68,18 @@ private Q_SLOTS:
         QCOMPARE(pointLight.type(), Qt3DRender::QLight::PointLight);
         pointLight.setColor(Qt::green);
         pointLight.setIntensity(0.5f);
-        pointLight.setAttenuation(QVector3D(0.5f, 0.0f, 1.0f));
+        pointLight.setConstantAttenuation(0.5f);
+        pointLight.setLinearAttenuation(0.0f);      // No actual event triggered as 0.0f is default
+        pointLight.setQuadraticAttenuation(1.0f);
 
         QScopedPointer<Qt3DRender::QPointLight> pointLightClone(static_cast<Qt3DRender::QPointLight *>(QNode::clone(&pointLight)));
         QVERIFY(pointLightClone.data());
         QCOMPARE(pointLightClone->type(), Qt3DRender::QLight::PointLight);
         QCOMPARE(pointLight.color(), pointLightClone->color());
         QCOMPARE(pointLight.intensity(), pointLightClone->intensity());
-        QCOMPARE(pointLight.attenuation(), pointLightClone->attenuation());
+        QCOMPARE(pointLight.constantAttenuation(), pointLightClone->constantAttenuation());
+        QCOMPARE(pointLight.linearAttenuation(), pointLightClone->linearAttenuation());
+        QCOMPARE(pointLight.quadraticAttenuation(), pointLightClone->quadraticAttenuation());
     }
 
     void checkDirectionalLightCloning()
@@ -150,10 +154,12 @@ private Q_SLOTS:
 
         pointLight->setColor(Qt::green);
         pointLight->setIntensity(0.5f);
-        pointLight->setAttenuation(QVector3D(0.5f, 0.0f, 1.0f));
+        pointLight->setConstantAttenuation(0.5f);
+        pointLight->setLinearAttenuation(0.0f);     // No actual event triggered as 0.0f is default
+        pointLight->setQuadraticAttenuation(1.0f);
         QCoreApplication::processEvents();
 
-        QCOMPARE(pointLightArbiter.events.size(), 3);
+        QCOMPARE(pointLightArbiter.events.size(), 4);
         Qt3DCore::QScenePropertyChangePtr change = pointLightArbiter.events[0].staticCast<Qt3DCore::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "color");
         QCOMPARE(change->subjectId(), pointLight->id());
@@ -165,9 +171,14 @@ private Q_SLOTS:
         QCOMPARE(change->value().value<float>(), 0.5f);
         QCOMPARE(change->type(), Qt3DCore::NodeUpdated);
         change = pointLightArbiter.events[2].staticCast<Qt3DCore::QScenePropertyChange>();
-        QCOMPARE(change->propertyName(), "attenuation");
+        QCOMPARE(change->propertyName(), "constantAttenuation");
         QCOMPARE(change->subjectId(), pointLight->id());
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(0.5f, 0.0f, 1.0f));
+        QCOMPARE(change->value().value<float>(), 0.5f);
+        QCOMPARE(change->type(), Qt3DCore::NodeUpdated);
+        change = pointLightArbiter.events[3].staticCast<Qt3DCore::QScenePropertyChange>();
+        QCOMPARE(change->propertyName(), "quadraticAttenuation");
+        QCOMPARE(change->subjectId(), pointLight->id());
+        QCOMPARE(change->value().value<float>(), 1.0f);
         QCOMPARE(change->type(), Qt3DCore::NodeUpdated);
 
         pointLightArbiter.events.clear();