Class QGeometryFunctor renamed to QGeometryFactory

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

12 files changed, 91 insertions, 91 deletions

diff --git a/src/render/geometry/geometry.pri b/src/render/geometry/geometry.pri
index a83cfe9c1..9f353e891 100644
--- a/src/render/geometry/geometry.pri
+++ b/src/render/geometry/geometry.pri
@@ -18,7 +18,7 @@ HEADERS += \
     $$PWD/qcylindermesh.h \
     $$PWD/qgeometry.h \
     $$PWD/qgeometry_p.h \
-    $$PWD/qgeometryfunctor.h \
+    $$PWD/qgeometryfactory.h \
     $$PWD/qgeometryrenderer.h \
     $$PWD/qgeometryrenderer_p.h \
     $$PWD/qmesh.h \
diff --git a/src/render/geometry/geometryrenderer.cpp b/src/render/geometry/geometryrenderer.cpp
index 647c419c2..ec222d53e 100644
--- a/src/render/geometry/geometryrenderer.cpp
+++ b/src/render/geometry/geometryrenderer.cpp
@@ -84,7 +84,7 @@ void GeometryRenderer::cleanup()
     m_geometryId = Qt3DCore::QNodeId();
     m_dirty = false;
     m_enabled = true;
-    m_functor.reset();
+    m_geometryFactory.reset();
     qDeleteAll(m_triangleVolumes);
     m_triangleVolumes.clear();
 }
@@ -109,8 +109,8 @@ void GeometryRenderer::updateFromPeer(Qt3DCore::QNode *peer)
         m_enabled = geometryRenderer->isEnabled();
         if (geometryRenderer->geometry() != Q_NULLPTR)
             m_geometryId = geometryRenderer->geometry()->id();
-        m_functor = geometryRenderer->geometryFunctor();
-        if (m_functor && m_manager != Q_NULLPTR)
+        m_geometryFactory = geometryRenderer->geometryFactory();
+        if (m_geometryFactory && m_manager != Q_NULLPTR)
             m_manager->addDirtyGeometryRenderer(peerId());
         m_dirty = true;
     }
@@ -150,11 +150,11 @@ void GeometryRenderer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         } else if (propertyName == QByteArrayLiteral("primitiveType")) {
             m_primitiveType = static_cast<QGeometryRenderer::PrimitiveType>(propertyChange->value().value<int>());
             m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("geometryFunctor")) {
-            QGeometryFunctorPtr newFunctor = propertyChange->value().value<QGeometryFunctorPtr>();
-            m_dirty |= !(newFunctor && m_functor && *newFunctor == *m_functor);
-            m_functor = newFunctor;
-            if (m_functor && m_manager != Q_NULLPTR)
+        } else if (propertyName == QByteArrayLiteral("geometryFactory")) {
+            QGeometryFactoryPtr newFunctor = propertyChange->value().value<QGeometryFactoryPtr>();
+            m_dirty |= !(newFunctor && m_geometryFactory && *newFunctor == *m_geometryFactory);
+            m_geometryFactory = newFunctor;
+            if (m_geometryFactory && m_manager != Q_NULLPTR)
                 m_manager->addDirtyGeometryRenderer(peerId());
         }
         break;
@@ -187,8 +187,8 @@ void GeometryRenderer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 
 void GeometryRenderer::executeFunctor()
 {
-    Q_ASSERT(m_functor);
-    QGeometry *geometry = (*m_functor)();
+    Q_ASSERT(m_geometryFactory);
+    QGeometry *geometry = (*m_geometryFactory)();
 
     QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
     e->setPropertyName("geometry");
diff --git a/src/render/geometry/geometryrenderer_p.h b/src/render/geometry/geometryrenderer_p.h
index 9f30535e4..b94c18dc9 100644
--- a/src/render/geometry/geometryrenderer_p.h
+++ b/src/render/geometry/geometryrenderer_p.h
@@ -53,7 +53,7 @@
 
 #include <Qt3DRender/private/backendnode_p.h>
 #include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -88,7 +88,7 @@ public:
     inline QGeometryRenderer::PrimitiveType primitiveType() const { return m_primitiveType; }
     inline bool isDirty() const { return m_dirty; }
     inline bool isEnabled() const { return m_enabled; }
-    inline QGeometryFunctorPtr geometryFunctor() const { return m_functor; }
+    inline QGeometryFactoryPtr geometryFactory() const { return m_geometryFactory; }
     void unsetDirty();
 
     // Build triangle data Job thread
@@ -108,7 +108,7 @@ private:
     QGeometryRenderer::PrimitiveType m_primitiveType;
     bool m_dirty;
     bool m_enabled;
-    QGeometryFunctorPtr m_functor;
+    QGeometryFactoryPtr m_geometryFactory;
     GeometryRendererManager *m_manager;
     QVector<QBoundingVolume *> m_triangleVolumes;
 };
diff --git a/src/render/geometry/qgeometryfunctor.h b/src/render/geometry/qgeometryfactory.h
index 548c9f9a7..b9f722844 100644
--- a/src/render/geometry/qgeometryfunctor.h
+++ b/src/render/geometry/qgeometryfactory.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_QGEOMETRYFUNCTOR
-#define QT3DRENDER_QGEOMETRYFUNCTOR
+#ifndef QT3DRENDER_QGEOMETRYFACTORY
+#define QT3DRENDER_QGEOMETRYFACTORY
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DRender/qabstractfunctor.h>
@@ -50,21 +50,21 @@ namespace Qt3DRender {
 
 class QGeometry;
 
-class QT3DRENDERSHARED_EXPORT QGeometryFunctor : public QAbstractFunctor
+class QT3DRENDERSHARED_EXPORT QGeometryFactory : public QAbstractFunctor
 {
 public:
-    virtual ~QGeometryFunctor() {}
+    virtual ~QGeometryFactory() {}
     virtual QGeometry *operator()() = 0;
-    virtual bool operator ==(const QGeometryFunctor &other) const = 0;
+    virtual bool operator ==(const QGeometryFactory &other) const = 0;
 };
 
-typedef QSharedPointer<QGeometryFunctor> QGeometryFunctorPtr;
+typedef QSharedPointer<QGeometryFactory> QGeometryFactoryPtr;
 
 } // namespace Qt3DRender
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(Qt3DRender::QGeometryFunctorPtr)
+Q_DECLARE_METATYPE(Qt3DRender::QGeometryFactoryPtr)
 
-#endif // QT3DRENDER_QGEOMETRYFUNCTOR
+#endif // QT3DRENDER_QGEOMETRYFACTORY
 
diff --git a/src/render/geometry/qgeometryrenderer.cpp b/src/render/geometry/qgeometryrenderer.cpp
index 6770fd8af..c89a8b417 100644
--- a/src/render/geometry/qgeometryrenderer.cpp
+++ b/src/render/geometry/qgeometryrenderer.cpp
@@ -276,10 +276,10 @@ QGeometryRenderer::PrimitiveType QGeometryRenderer::primitiveType() const
 /*!
  * \return the geometry functor.
  */
-QGeometryFunctorPtr QGeometryRenderer::geometryFunctor() const
+QGeometryFactoryPtr QGeometryRenderer::geometryFactory() const
 {
     Q_D(const QGeometryRenderer);
-    return d->m_functor;
+    return d->m_geometryFactory;
 }
 
 void QGeometryRenderer::setInstanceCount(int instanceCount)
@@ -393,16 +393,16 @@ void QGeometryRenderer::setPrimitiveType(QGeometryRenderer::PrimitiveType primit
 /*!
  * Sets the geometry \a functor.
  */
-void QGeometryRenderer::setGeometryFunctor(const QGeometryFunctorPtr &functor)
+void QGeometryRenderer::setGeometryFactory(const QGeometryFactoryPtr &factory)
 {
     Q_D(QGeometryRenderer);
-    if (functor && d->m_functor && *functor == *d->m_functor)
+    if (factory && d->m_geometryFactory && *factory == *d->m_geometryFactory)
         return;
-    d->m_functor = functor;
+    d->m_geometryFactory = factory;
     if (d->m_changeArbiter != Q_NULLPTR) {
         QScenePropertyChangePtr change(new QScenePropertyChange(NodeUpdated, QSceneChange::Node, id()));
-        change->setPropertyName("geometryFunctor");
-        change->setValue(QVariant::fromValue(d->m_functor));
+        change->setPropertyName("geometryFactory");
+        change->setValue(QVariant::fromValue(d->m_geometryFactory));
         d->notifyObservers(change);
     }
 }
@@ -423,7 +423,7 @@ void QGeometryRenderer::copy(const QNode *ref)
     d_func()->m_primitiveType = other->d_func()->m_primitiveType;
     d_func()->m_verticesPerPatch = other->d_func()->m_verticesPerPatch;
     d_func()->m_geometry = static_cast<QGeometry *>(QNode::clone(other->d_func()->m_geometry));
-    d_func()->m_functor = other->d_func()->m_functor;
+    d_func()->m_geometryFactory = other->d_func()->m_geometryFactory;
 }
 
 /*!
diff --git a/src/render/geometry/qgeometryrenderer.h b/src/render/geometry/qgeometryrenderer.h
index 8a458d988..836a1cc0e 100644
--- a/src/render/geometry/qgeometryrenderer.h
+++ b/src/render/geometry/qgeometryrenderer.h
@@ -49,9 +49,9 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 class QGeometryRendererPrivate;
-class QGeometryFunctor;
+class QGeometryFactory;
 
-typedef QSharedPointer<QGeometryFunctor> QGeometryFunctorPtr;
+typedef QSharedPointer<QGeometryFactory> QGeometryFactoryPtr;
 
 class QT3DRENDERSHARED_EXPORT QGeometryRenderer : public Qt3DCore::QComponent
 {
@@ -99,8 +99,8 @@ public:
     QGeometry *geometry() const;
     PrimitiveType primitiveType() const;
 
-    QGeometryFunctorPtr geometryFunctor() const;
-    void setGeometryFunctor(const QGeometryFunctorPtr &functor);
+    QGeometryFactoryPtr geometryFactory() const;
+    void setGeometryFactory(const QGeometryFactoryPtr &factory);
 
 public Q_SLOTS:
     void setInstanceCount(int instanceCount);
diff --git a/src/render/geometry/qgeometryrenderer_p.h b/src/render/geometry/qgeometryrenderer_p.h
index bbc52c46d..359819349 100644
--- a/src/render/geometry/qgeometryrenderer_p.h
+++ b/src/render/geometry/qgeometryrenderer_p.h
@@ -53,7 +53,7 @@
 
 #include <Qt3DCore/private/qcomponent_p.h>
 #include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -74,7 +74,7 @@ public:
     bool m_primitiveRestart;
     QGeometry *m_geometry;
     QGeometryRenderer::PrimitiveType m_primitiveType;
-    QGeometryFunctorPtr m_functor;
+    QGeometryFactoryPtr m_geometryFactory;
 };
 
 } // namespace Qt3DRender
diff --git a/src/render/geometry/qmesh.cpp b/src/render/geometry/qmesh.cpp
index 0296cf031..da78eaed3 100644
--- a/src/render/geometry/qmesh.cpp
+++ b/src/render/geometry/qmesh.cpp
@@ -52,12 +52,12 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
-class MeshFunctor : public QGeometryFunctor
+class MeshFunctor : public QGeometryFactory
 {
 public :
     MeshFunctor(const QUrl &sourcePath, const QString &meshName = QString());
     QGeometry *operator()() Q_DECL_OVERRIDE;
-    bool operator ==(const QGeometryFunctor &other) const Q_DECL_OVERRIDE;
+    bool operator ==(const QGeometryFactory &other) const Q_DECL_OVERRIDE;
     QT3D_FUNCTOR(MeshFunctor)
 
 private:
@@ -128,7 +128,7 @@ void QMesh::setSource(const QUrl& source)
         return;
     d->m_source = source;
     // update the functor
-    QGeometryRenderer::setGeometryFunctor(QGeometryFunctorPtr(new MeshFunctor(d->m_source, d->m_meshName)));
+    QGeometryRenderer::setGeometryFactory(QGeometryFactoryPtr(new MeshFunctor(d->m_source, d->m_meshName)));
     emit sourceChanged(source);
 }
 
@@ -150,7 +150,7 @@ void QMesh::setMeshName(const QString &meshName)
         return;
     d->m_meshName = meshName;
     // update the functor
-    QGeometryRenderer::setGeometryFunctor(QGeometryFunctorPtr(new MeshFunctor(d->m_source, d->m_meshName)));
+    QGeometryRenderer::setGeometryFactory(QGeometryFactoryPtr(new MeshFunctor(d->m_source, d->m_meshName)));
     emit meshNameChanged(meshName);
 }
 
@@ -169,7 +169,7 @@ QString QMesh::meshName() const
  * \internal
  */
 MeshFunctor::MeshFunctor(const QUrl &sourcePath, const QString& meshName)
-    : QGeometryFunctor()
+    : QGeometryFactory()
     , m_sourcePath(sourcePath)
     , m_meshName(meshName)
 {
@@ -205,7 +205,7 @@ QGeometry *MeshFunctor::operator()()
 /*!
  * \internal
  */
-bool MeshFunctor::operator ==(const QGeometryFunctor &other) const
+bool MeshFunctor::operator ==(const QGeometryFactory &other) const
 {
     const MeshFunctor *otherFunctor = functor_cast<MeshFunctor>(&other);
     if (otherFunctor != Q_NULLPTR)
diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
index ab883f6d9..27de35b8e 100644
--- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
+++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
@@ -29,14 +29,14 @@
 #include <QtTest/QTest>
 #include <Qt3DRender/private/geometryrenderer_p.h>
 #include <Qt3DRender/qgeometry.h>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DCore/qscenepropertychange.h>
 #include "testrenderer.h"
 
-class TestFunctor : public Qt3DRender::QGeometryFunctor
+class TestFactory : public Qt3DRender::QGeometryFactory
 {
 public:
-    explicit TestFunctor(int size)
+    explicit TestFactory(int size)
         : m_size(size)
     {}
 
@@ -45,15 +45,15 @@ public:
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const
+    bool operator ==(const Qt3DRender::QGeometryFactory &other) const
     {
-        const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
-        if (otherFunctor != Q_NULLPTR)
-            return otherFunctor->m_size == m_size;
+        const TestFactory *otherFactory = functor_cast<TestFactory>(&other);
+        if (otherFactory != Q_NULLPTR)
+            return otherFactory->m_size == m_size;
         return false;
     }
 
-    QT3D_FUNCTOR(TestFunctor)
+    QT3D_FUNCTOR(TestFactory)
 
 private:
     int m_size;
@@ -70,7 +70,7 @@ private Q_SLOTS:
         Qt3DRender::Render::GeometryRenderer renderGeometryRenderer;
         Qt3DRender::QGeometryRenderer geometryRenderer;
         Qt3DRender::QGeometry geometry;
-        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1200));
+        Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(1200));
 
         geometryRenderer.setInstanceCount(1584);
         geometryRenderer.setPrimitiveCount(1609);
@@ -80,7 +80,7 @@ private Q_SLOTS:
         geometryRenderer.setPrimitiveRestart(true);
         geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         geometryRenderer.setGeometry(&geometry);
-        geometryRenderer.setGeometryFunctor(functor);
+        geometryRenderer.setGeometryFactory(factory);
         geometryRenderer.setEnabled(false);
 
         // WHEN
@@ -97,9 +97,9 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.primitiveRestart(), geometryRenderer.primitiveRestart());
         QCOMPARE(renderGeometryRenderer.primitiveType(), geometryRenderer.primitiveType());
         QCOMPARE(renderGeometryRenderer.geometryId(), geometry.id());
-        QCOMPARE(renderGeometryRenderer.geometryFunctor(), functor);
+        QCOMPARE(renderGeometryRenderer.geometryFactory(), factory);
         QCOMPARE(renderGeometryRenderer.isEnabled(), false);
-        QVERIFY(*renderGeometryRenderer.geometryFunctor() == *functor);
+        QVERIFY(*renderGeometryRenderer.geometryFactory() == *factory);
     }
 
     void checkInitialAndCleanedUpState()
@@ -118,13 +118,13 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.restartIndex(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestart(), false);
         QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
-        QVERIFY(renderGeometryRenderer.geometryFunctor().isNull());
+        QVERIFY(renderGeometryRenderer.geometryFactory().isNull());
         QVERIFY(renderGeometryRenderer.isEnabled());
 
         // GIVEN
         Qt3DRender::QGeometryRenderer geometryRenderer;
         Qt3DRender::QGeometry geometry;
-        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1200));
+        Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(1200));
 
 
         geometryRenderer.setInstanceCount(454);
@@ -135,7 +135,7 @@ private Q_SLOTS:
         geometryRenderer.setPrimitiveRestart(true);
         geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         geometryRenderer.setGeometry(&geometry);
-        geometryRenderer.setGeometryFunctor(functor);
+        geometryRenderer.setGeometryFactory(factory);
         geometryRenderer.setEnabled(false);
 
         // WHEN
@@ -153,7 +153,7 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.restartIndex(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestart(), false);
         QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
-        QVERIFY(renderGeometryRenderer.geometryFunctor().isNull());
+        QVERIFY(renderGeometryRenderer.geometryFactory().isNull());
         QVERIFY(renderGeometryRenderer.isEnabled());
     }
 
@@ -260,13 +260,13 @@ private Q_SLOTS:
 
         // WHEN
         updateChange.reset(new Qt3DCore::QScenePropertyChange(Qt3DCore::NodeUpdated, Qt3DCore::QSceneChange::Node, Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("geometryFunctor");
-        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1450));
-        updateChange->setValue(QVariant::fromValue(functor));
+        updateChange->setPropertyName("geometryFactory");
+        Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(1450));
+        updateChange->setValue(QVariant::fromValue(factory));
         renderGeometryRenderer.sceneChangeEvent(updateChange);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.geometryFunctor(), functor);
+        QCOMPARE(renderGeometryRenderer.geometryFactory(), factory);
         QVERIFY(renderGeometryRenderer.isDirty());
 
         renderGeometryRenderer.unsetDirty();
diff --git a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
index ccbfabcc6..0f50d929f 100644
--- a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
+++ b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
@@ -27,10 +27,10 @@
 ****************************************************************************/
 
 #include <QtTest/QtTest>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DRender/qgeometry.h>
 
-class MeshFunctorA : public Qt3DRender::QGeometryFunctor
+class MeshFunctorA : public Qt3DRender::QGeometryFactory
 {
 public:
     MeshFunctorA()
@@ -44,7 +44,7 @@ public:
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorA>(&other);
     }
@@ -52,7 +52,7 @@ public:
     QT3D_FUNCTOR(MeshFunctorA)
 };
 
-class MeshFunctorB : public Qt3DRender::QGeometryFunctor
+class MeshFunctorB : public Qt3DRender::QGeometryFactory
 {
 public:
     MeshFunctorB()
@@ -66,7 +66,7 @@ public:
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorB>(&other);
     }
@@ -83,7 +83,7 @@ public:
     ~MeshFunctorASub()
     {}
 
-    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorASub>(&other);
     }
diff --git a/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp b/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp
index 063a80723..6ef130ca8 100644
--- a/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp
+++ b/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp
@@ -29,7 +29,7 @@
 #include <QtTest/QTest>
 
 #include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
@@ -84,10 +84,10 @@ private Q_SLOTS:
         QCOMPARE(clone->primitiveRestart(), geomRenderer->primitiveRestart());
         QCOMPARE(clone->primitiveType(), geomRenderer->primitiveType());
 
-        QCOMPARE(clone->geometryFunctor(), geomRenderer->geometryFunctor());
-        if (geomRenderer->geometryFunctor()) {
-            QVERIFY(clone->geometryFunctor());
-            QVERIFY(*clone->geometryFunctor() == *geomRenderer->geometryFunctor());
+        QCOMPARE(clone->geometryFactory(), geomRenderer->geometryFactory());
+        if (geomRenderer->geometryFactory()) {
+            QVERIFY(clone->geometryFactory());
+            QVERIFY(*clone->geometryFactory() == *geomRenderer->geometryFactory());
         }
 
         if (geomRenderer->geometry() != Q_NULLPTR) {
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index 0912f4b9a..ddd2eb500 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -31,17 +31,17 @@
 #include <Qt3DCore/private/qscene_p.h>
 
 #include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfunctor.h>
+#include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
 
 #include "testpostmanarbiter.h"
 
-class TestFunctor : public Qt3DRender::QGeometryFunctor
+class TestFactory : public Qt3DRender::QGeometryFactory
 {
 public:
-    explicit TestFunctor(int size)
+    explicit TestFactory(int size)
         : m_size(size)
     {}
 
@@ -50,15 +50,15 @@ public:
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const
+    bool operator ==(const Qt3DRender::QGeometryFactory &other) const
     {
-        const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
-        if (otherFunctor != Q_NULLPTR)
-            return otherFunctor->m_size == m_size;
+        const TestFactory *otherFactory = functor_cast<TestFactory>(&other);
+        if (otherFactory != Q_NULLPTR)
+            return otherFactory->m_size == m_size;
         return false;
     }
 
-    QT3D_FUNCTOR(TestFunctor)
+    QT3D_FUNCTOR(TestFactory)
 
 private:
     int m_size;
@@ -94,7 +94,7 @@ private Q_SLOTS:
         geometry1->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
         geometry1->setPrimitiveCount(15);
         geometry1->setVerticesPerPatch(2);
-        geometry1->setGeometryFunctor(Qt3DRender::QGeometryFunctorPtr(new TestFunctor(383)));
+        geometry1->setGeometryFactory(Qt3DRender::QGeometryFactoryPtr(new TestFactory(383)));
         QTest::newRow("triangle") << geometry1;
 
         Qt3DRender::QGeometryRenderer *geometry2 = new Qt3DRender::QGeometryRenderer();
@@ -107,7 +107,7 @@ private Q_SLOTS:
         geometry2->setPrimitiveRestart(true);
         geometry2->setVerticesPerPatch(3);
         geometry2->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
-        geometry2->setGeometryFunctor(Qt3DRender::QGeometryFunctorPtr(new TestFunctor(305)));
+        geometry2->setGeometryFactory(Qt3DRender::QGeometryFactoryPtr(new TestFactory(305)));
         QTest::newRow("lines with restart") << geometry2;
     }
 
@@ -137,10 +137,10 @@ private Q_SLOTS:
             QCOMPARE(clone->geometry()->id(), geometryRenderer->geometry()->id());
         }
 
-        QCOMPARE(clone->geometryFunctor(), geometryRenderer->geometryFunctor());
-        if (geometryRenderer->geometryFunctor()) {
-            QVERIFY(clone->geometryFunctor());
-            QVERIFY(*clone->geometryFunctor() == *geometryRenderer->geometryFunctor());
+        QCOMPARE(clone->geometryFactory(), geometryRenderer->geometryFactory());
+        if (geometryRenderer->geometryFactory()) {
+            QVERIFY(clone->geometryFactory());
+            QVERIFY(*clone->geometryFactory() == *geometryRenderer->geometryFactory());
         }
     }
 
@@ -255,15 +255,15 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(555));
-        geometryRenderer->setGeometryFunctor(functor);
+        Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(555));
+        geometryRenderer->setGeometryFactory(factory);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3DCore::QScenePropertyChange>();
-        QCOMPARE(change->propertyName(), "geometryFunctor");
-        QCOMPARE(change->value().value<Qt3DRender::QGeometryFunctorPtr>(), functor);
+        QCOMPARE(change->propertyName(), "geometryFactory");
+        QCOMPARE(change->value().value<Qt3DRender::QGeometryFactoryPtr>(), factory);
         QCOMPARE(change->type(), Qt3DCore::NodeUpdated);
 
         arbiter.events.clear();