Remove buffer functor API

Change-Id: I78cc60ff634f909111b891d5b9716e19cae35f3b
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

36 files changed, 164 insertions, 960 deletions

diff --git a/src/extras/3dtext/qextrudedtextgeometry.cpp b/src/extras/3dtext/qextrudedtextgeometry.cpp
index 4a81ae44a..3c4580c65 100644
--- a/src/extras/3dtext/qextrudedtextgeometry.cpp
+++ b/src/extras/3dtext/qextrudedtextgeometry.cpp
@@ -51,7 +51,6 @@
 #include "qextrudedtextgeometry.h"
 #include "qextrudedtextgeometry_p.h"
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <private/qtriangulator_p.h>
 #include <qmath.h>
diff --git a/src/extras/geometries/qconegeometry.cpp b/src/extras/geometries/qconegeometry.cpp
index 2cf526142..af9941394 100644
--- a/src/extras/geometries/qconegeometry.cpp
+++ b/src/extras/geometries/qconegeometry.cpp
@@ -60,7 +60,6 @@
 #include "qconegeometry_p.h"
 
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <QtGui/QVector3D>
 
@@ -224,125 +223,6 @@ void createDiscIndices(quint16 *&indicesPtr,
 
 } // anonymous
 
-
-class ConeVertexDataFunctor : public QBufferDataGenerator
-{
-public:
-    ConeVertexDataFunctor(bool hasTopEndcap, bool hasBottomEndcap, int rings, int slices,
-                          float topRadius, float bottomRadius, float length)
-        : m_hasTopEndcap(hasTopEndcap)
-        , m_hasBottomEndcap(hasBottomEndcap)
-        , m_rings(rings)
-        , m_slices(slices)
-        , m_topRadius(topRadius)
-        , m_bottomRadius(bottomRadius)
-        , m_length(length)
-    {}
-
-    QByteArray operator ()() override
-    {
-        const int verticesCount =
-                vertexCount(m_slices, m_rings, (m_hasTopEndcap + m_hasBottomEndcap));
-
-        // vec3 pos, vec2 texCoord, vec3 normal
-        const quint32 vertexSize = (3 + 2 + 3) * sizeof(float);
-
-        QByteArray verticesData;
-        verticesData.resize(vertexSize * verticesCount);
-        float *verticesPtr = reinterpret_cast<float*>(verticesData.data());
-
-        createSidesVertices(verticesPtr, m_rings, m_slices, m_topRadius, m_bottomRadius, m_length);
-        if ( m_hasTopEndcap )
-            createDiscVertices(verticesPtr, m_slices, m_topRadius, m_bottomRadius, m_length, m_length * 0.5f);
-        if ( m_hasBottomEndcap )
-            createDiscVertices(verticesPtr, m_slices, m_topRadius, m_bottomRadius, m_length, -m_length * 0.5f);
-
-        return verticesData;
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const ConeVertexDataFunctor *otherFunctor = functor_cast<ConeVertexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_hasTopEndcap == m_hasTopEndcap &&
-                    otherFunctor->m_hasBottomEndcap == m_hasBottomEndcap &&
-                    otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_topRadius == m_topRadius &&
-                    otherFunctor->m_bottomRadius == m_bottomRadius &&
-                    otherFunctor->m_length == m_length);
-        return false;
-    }
-
-    QT3D_FUNCTOR(ConeVertexDataFunctor)
-
-private:
-    bool m_hasTopEndcap;
-    bool m_hasBottomEndcap;
-    int m_rings;
-    int m_slices;
-    float m_topRadius;
-    float m_bottomRadius;
-    float m_length;
-};
-
-class ConeIndexDataFunctor : public QBufferDataGenerator
-{
-public:
-    ConeIndexDataFunctor(bool hasTopEndcap, bool hasBottomEndcap, int rings, int slices,
-                         float length)
-        : m_hasTopEndcap(hasTopEndcap)
-        , m_hasBottomEndcap(hasBottomEndcap)
-        , m_rings(rings)
-        , m_slices(slices)
-        , m_length(length)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        const int facesCount = faceCount(m_slices, m_rings, (m_hasTopEndcap + m_hasBottomEndcap));
-
-        const int indicesCount = facesCount * 3;
-        const int indexSize = sizeof(quint16);
-        Q_ASSERT(indicesCount < 65536);
-
-        QByteArray indicesBytes;
-        indicesBytes.resize(indicesCount * indexSize);
-        quint16 *indicesPtr = reinterpret_cast<quint16*>(indicesBytes.data());
-
-        createSidesIndices(indicesPtr, m_rings, m_slices);
-        if ( m_hasTopEndcap )
-            createDiscIndices(indicesPtr, m_rings * (m_slices + 1) + m_slices + 2, m_slices, true);
-        if ( m_hasBottomEndcap )
-            createDiscIndices(indicesPtr, m_rings * (m_slices + 1), m_slices, false);
-
-        return indicesBytes;
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const ConeIndexDataFunctor *otherFunctor = functor_cast<ConeIndexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_hasTopEndcap == m_hasTopEndcap &&
-                    otherFunctor->m_hasBottomEndcap == m_hasBottomEndcap &&
-                    otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_length == m_length);
-        return false;
-    }
-
-    QT3D_FUNCTOR(ConeIndexDataFunctor)
-
-private:
-    bool m_hasTopEndcap;
-    bool m_hasBottomEndcap;
-    int m_rings;
-    int m_slices;
-    float m_length;
-};
-
-
 QConeGeometryPrivate::QConeGeometryPrivate()
     : QGeometryPrivate()
     , m_hasTopEndcap(true)
@@ -410,10 +290,8 @@ void QConeGeometryPrivate::init()
 
     m_indexAttribute->setCount(faces * 3);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<ConeVertexDataFunctor>::create(m_hasTopEndcap, m_hasBottomEndcap, m_rings, m_slices,
-                                                                                   m_topRadius, m_bottomRadius, m_length));
-    m_indexBuffer->setDataGenerator(QSharedPointer<ConeIndexDataFunctor>::create(m_hasTopEndcap, m_hasBottomEndcap, m_rings, m_slices,
-                                                                                 m_length));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -421,6 +299,48 @@ void QConeGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QConeGeometryPrivate::generateVertexData() const
+{
+    const int verticesCount =
+        vertexCount(m_slices, m_rings, (m_hasTopEndcap + m_hasBottomEndcap));
+
+    // vec3 pos, vec2 texCoord, vec3 normal
+    const quint32 vertexSize = (3 + 2 + 3) * sizeof(float);
+
+    QByteArray verticesData;
+    verticesData.resize(vertexSize * verticesCount);
+    float *verticesPtr = reinterpret_cast<float*>(verticesData.data());
+
+    createSidesVertices(verticesPtr, m_rings, m_slices, m_topRadius, m_bottomRadius, m_length);
+    if ( m_hasTopEndcap )
+        createDiscVertices(verticesPtr, m_slices, m_topRadius, m_bottomRadius, m_length, m_length * 0.5f);
+    if ( m_hasBottomEndcap )
+        createDiscVertices(verticesPtr, m_slices, m_topRadius, m_bottomRadius, m_length, -m_length * 0.5f);
+
+    return verticesData;
+}
+
+QByteArray QConeGeometryPrivate::generateIndexData() const
+{
+    const int facesCount = faceCount(m_slices, m_rings, (m_hasTopEndcap + m_hasBottomEndcap));
+
+    const int indicesCount = facesCount * 3;
+    const int indexSize = sizeof(quint16);
+    Q_ASSERT(indicesCount < 65536);
+
+    QByteArray indicesBytes;
+    indicesBytes.resize(indicesCount * indexSize);
+    quint16 *indicesPtr = reinterpret_cast<quint16*>(indicesBytes.data());
+
+    createSidesIndices(indicesPtr, m_rings, m_slices);
+    if ( m_hasTopEndcap )
+        createDiscIndices(indicesPtr, m_rings * (m_slices + 1) + m_slices + 2, m_slices, true);
+    if ( m_hasBottomEndcap )
+        createDiscIndices(indicesPtr, m_rings * (m_slices + 1), m_slices, false);
+
+    return indicesBytes;
+}
+
 /*!
  * \qmltype ConeGeometry
  * \instantiates Qt3DExtras::QConeGeometry
@@ -530,8 +450,7 @@ void QConeGeometry::updateVertices()
     d->m_positionAttribute->setCount(nVerts);
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_normalAttribute->setCount(nVerts);
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<ConeVertexDataFunctor>::create(d->m_hasTopEndcap, d->m_hasBottomEndcap, d->m_rings, d->m_slices,
-                                                                                      d->m_topRadius, d->m_bottomRadius, d->m_length));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 /*!
@@ -544,8 +463,7 @@ void QConeGeometry::updateIndices()
                                 (d->m_hasTopEndcap + d->m_hasBottomEndcap));
 
     d->m_indexAttribute->setCount(faces * 3);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<ConeIndexDataFunctor>::create(d->m_hasTopEndcap, d->m_hasBottomEndcap, d->m_rings, d->m_slices,
-                                                                                    d->m_length));
+    d->m_indexBuffer->setData(d->generateIndexData());
 }
 
 /*!
diff --git a/src/extras/geometries/qconegeometry_p.h b/src/extras/geometries/qconegeometry_p.h
index 3987b4315..39c3913fc 100644
--- a/src/extras/geometries/qconegeometry_p.h
+++ b/src/extras/geometries/qconegeometry_p.h
@@ -87,6 +87,9 @@ public:
     Qt3DRender::QBuffer *m_positionBuffer;
     Qt3DRender::QBuffer *m_vertexBuffer;
     Qt3DRender::QBuffer *m_indexBuffer;
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/extras/geometries/qconemesh.cpp b/src/extras/geometries/qconemesh.cpp
index a0d1bd310..d54e43e1f 100644
--- a/src/extras/geometries/qconemesh.cpp
+++ b/src/extras/geometries/qconemesh.cpp
@@ -45,7 +45,6 @@
 
 #include <Qt3DExtras/qconemesh.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <QtGui/QVector3D>
 
diff --git a/src/extras/geometries/qcuboidgeometry.cpp b/src/extras/geometries/qcuboidgeometry.cpp
index f9efaaf9d..1f86defb4 100644
--- a/src/extras/geometries/qcuboidgeometry.cpp
+++ b/src/extras/geometries/qcuboidgeometry.cpp
@@ -42,7 +42,6 @@
 
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/private/renderlogging_p.h>
 
 #include <limits>
@@ -386,91 +385,6 @@ QByteArray createCuboidIndexData(const QSize &yzResolution,
 
 } // anonymous
 
-class CuboidVertexBufferFunctor : public QBufferDataGenerator
-{
-public:
-    explicit CuboidVertexBufferFunctor(float xExtent,
-                                       float yExtent,
-                                       float zExtent,
-                                       const QSize &yzResolution,
-                                       const QSize &xzResolution,
-                                       const QSize &xyResolution)
-        : m_xExtent(xExtent)
-        , m_yExtent(yExtent)
-        , m_zExtent(zExtent)
-        , m_yzFaceResolution(yzResolution)
-        , m_xzFaceResolution(xzResolution)
-        , m_xyFaceResolution(xyResolution)
-    {}
-
-    ~CuboidVertexBufferFunctor() {}
-
-    QByteArray operator()() final
-    {
-        return createCuboidVertexData(m_xExtent, m_yExtent, m_zExtent,
-                                      m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const final
-    {
-        const CuboidVertexBufferFunctor *otherFunctor = functor_cast<CuboidVertexBufferFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_xExtent == m_xExtent &&
-                    otherFunctor->m_yExtent == m_yExtent &&
-                    otherFunctor->m_zExtent == m_zExtent &&
-                    otherFunctor->m_yzFaceResolution == m_yzFaceResolution &&
-                    otherFunctor->m_xzFaceResolution == m_xzFaceResolution &&
-                    otherFunctor->m_xyFaceResolution == m_xyFaceResolution);
-        return false;
-    }
-
-    QT3D_FUNCTOR(CuboidVertexBufferFunctor)
-
-private:
-    float m_xExtent;
-    float m_yExtent;
-    float m_zExtent;
-    QSize m_yzFaceResolution;
-    QSize m_xzFaceResolution;
-    QSize m_xyFaceResolution;
-};
-
-class CuboidIndexBufferFunctor : public QBufferDataGenerator
-{
-public:
-    explicit CuboidIndexBufferFunctor(const QSize &yzResolution,
-                                      const QSize &xzResolution,
-                                      const QSize &xyResolution)
-        : m_yzFaceResolution(yzResolution)
-        , m_xzFaceResolution(xzResolution)
-        , m_xyFaceResolution(xyResolution)
-    {}
-
-    ~CuboidIndexBufferFunctor() {}
-
-    QByteArray operator()() final
-    {
-        return createCuboidIndexData(m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const final
-    {
-        const CuboidIndexBufferFunctor *otherFunctor = functor_cast<CuboidIndexBufferFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_yzFaceResolution == m_yzFaceResolution &&
-                    otherFunctor->m_xzFaceResolution == m_xzFaceResolution &&
-                    otherFunctor->m_xyFaceResolution == m_xyFaceResolution);
-        return false;
-    }
-
-    QT3D_FUNCTOR(CuboidIndexBufferFunctor)
-
-private:
-    QSize m_yzFaceResolution;
-    QSize m_xzFaceResolution;
-    QSize m_xyFaceResolution;
-};
-
 QCuboidGeometryPrivate::QCuboidGeometryPrivate()
     : QGeometryPrivate()
     , m_xExtent(1.0f)
@@ -553,9 +467,8 @@ void QCuboidGeometryPrivate::init()
 
     m_indexAttribute->setCount(indexCount);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<CuboidVertexBufferFunctor>::create(m_xExtent, m_yExtent, m_zExtent,
-                                                                                       m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution));
-    m_indexBuffer->setDataGenerator(QSharedPointer<CuboidIndexBufferFunctor>::create(m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -564,6 +477,17 @@ void QCuboidGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QCuboidGeometryPrivate::generateVertexData() const
+{
+    return createCuboidVertexData(m_xExtent, m_yExtent, m_zExtent,
+                                  m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution);
+}
+
+QByteArray QCuboidGeometryPrivate::generateIndexData() const
+{
+    return createCuboidIndexData(m_yzFaceResolution, m_xzFaceResolution, m_xyFaceResolution);
+}
+
 /*!
  * \qmltype CuboidGeometry
  * \instantiates Qt3DExtras::QCuboidGeometry
@@ -699,8 +623,7 @@ void QCuboidGeometry::updateIndices()
     const int indexCount = 2 * (yzIndices + xzIndices + xyIndices);
 
     d->m_indexAttribute->setCount(indexCount);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<CuboidIndexBufferFunctor>::create(d->m_yzFaceResolution, d->m_xzFaceResolution, d->m_xyFaceResolution));
-
+    d->m_indexBuffer->setData(d->generateIndexData());
 }
 
 /*!
@@ -719,8 +642,7 @@ void QCuboidGeometry::updateVertices()
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_tangentAttribute->setCount(nVerts);
 
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<CuboidVertexBufferFunctor>::create(d->m_xExtent, d->m_yExtent, d->m_zExtent,
-                                                                                          d->m_yzFaceResolution, d->m_xzFaceResolution, d->m_xyFaceResolution));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 void QCuboidGeometry::setXExtent(float xExtent)
diff --git a/src/extras/geometries/qcuboidgeometry_p.h b/src/extras/geometries/qcuboidgeometry_p.h
index cfabc0388..2c0ea5524 100644
--- a/src/extras/geometries/qcuboidgeometry_p.h
+++ b/src/extras/geometries/qcuboidgeometry_p.h
@@ -91,6 +91,9 @@ public:
     Qt3DRender::QBuffer *m_indexBuffer;
 
     Q_DECLARE_PUBLIC(QCuboidGeometry)
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/extras/geometries/qcylindergeometry.cpp b/src/extras/geometries/qcylindergeometry.cpp
index 9d26068f2..a6bdc5f8d 100644
--- a/src/extras/geometries/qcylindergeometry.cpp
+++ b/src/extras/geometries/qcylindergeometry.cpp
@@ -45,7 +45,6 @@
 #include "qcylindergeometry_p.h"
 
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <QtGui/QVector3D>
 
@@ -181,102 +180,6 @@ void createDiscIndices(quint16 *&indicesPtr,
 
 } // anonymous
 
-
-class CylinderVertexDataFunctor : public QBufferDataGenerator
-{
-public:
-    CylinderVertexDataFunctor(int rings, int slices, float radius, float length)
-        : m_rings(rings)
-        , m_slices(slices)
-        , m_radius(radius)
-        , m_length(length)
-    {}
-
-    QByteArray operator ()() override
-    {
-        const int verticesCount = vertexCount(m_slices, m_rings);
-        // vec3 pos, vec2 texCoord, vec3 normal
-        const quint32 vertexSize = (3 + 2 + 3) * sizeof(float);
-
-        QByteArray verticesData;
-        verticesData.resize(vertexSize * verticesCount);
-        float *verticesPtr = reinterpret_cast<float*>(verticesData.data());
-
-        createSidesVertices(verticesPtr, m_rings, m_slices, m_radius, m_length);
-        createDiscVertices(verticesPtr, m_slices, m_radius, -m_length * 0.5f);
-        createDiscVertices(verticesPtr, m_slices, m_radius, m_length * 0.5f);
-
-        return verticesData;
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const CylinderVertexDataFunctor *otherFunctor = functor_cast<CylinderVertexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_radius == m_radius &&
-                    otherFunctor->m_length == m_length);
-        return false;
-    }
-
-    QT3D_FUNCTOR(CylinderVertexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-    float m_radius;
-    float m_length;
-};
-
-class CylinderIndexDataFunctor : public QBufferDataGenerator
-{
-public:
-    CylinderIndexDataFunctor(int rings, int slices, float length)
-        : m_rings(rings)
-        , m_slices(slices)
-        , m_length(length)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        const int facesCount = faceCount(m_slices, m_rings);
-        const int indicesCount = facesCount * 3;
-        const int indexSize = sizeof(quint16);
-        Q_ASSERT(indicesCount < 65536);
-
-        QByteArray indicesBytes;
-        indicesBytes.resize(indicesCount * indexSize);
-        quint16 *indicesPtr = reinterpret_cast<quint16*>(indicesBytes.data());
-
-        createSidesIndices(indicesPtr, m_rings, m_slices);
-        createDiscIndices(indicesPtr, m_rings * (m_slices + 1), m_slices, -m_length * 0.5);
-        createDiscIndices(indicesPtr, m_rings * (m_slices + 1) + m_slices + 2, m_slices, m_length * 0.5);
-        Q_ASSERT(indicesPtr == (reinterpret_cast<quint16*>(indicesBytes.data()) + indicesCount));
-
-        return indicesBytes;
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const CylinderIndexDataFunctor *otherFunctor = functor_cast<CylinderIndexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_length == m_length);
-        return false;
-    }
-
-    QT3D_FUNCTOR(CylinderIndexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-    float m_length;
-};
-
-
 QCylinderGeometryPrivate::QCylinderGeometryPrivate()
     : QGeometryPrivate()
     , m_rings(16)
@@ -340,8 +243,8 @@ void QCylinderGeometryPrivate::init()
 
     m_indexAttribute->setCount(faces * 3);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<CylinderVertexDataFunctor>::create(m_rings, m_slices, m_radius, m_length));
-    m_indexBuffer->setDataGenerator(QSharedPointer<CylinderIndexDataFunctor>::create(m_rings, m_slices, m_length));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -349,6 +252,42 @@ void QCylinderGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QCylinderGeometryPrivate::generateVertexData() const
+{
+    const int verticesCount = vertexCount(m_slices, m_rings);
+    // vec3 pos, vec2 texCoord, vec3 normal
+    const quint32 vertexSize = (3 + 2 + 3) * sizeof(float);
+
+    QByteArray verticesData;
+    verticesData.resize(vertexSize * verticesCount);
+    float *verticesPtr = reinterpret_cast<float*>(verticesData.data());
+
+    createSidesVertices(verticesPtr, m_rings, m_slices, m_radius, m_length);
+    createDiscVertices(verticesPtr, m_slices, m_radius, -m_length * 0.5f);
+    createDiscVertices(verticesPtr, m_slices, m_radius, m_length * 0.5f);
+
+    return verticesData;
+}
+
+QByteArray QCylinderGeometryPrivate::generateIndexData() const
+{
+    const int facesCount = faceCount(m_slices, m_rings);
+    const int indicesCount = facesCount * 3;
+    const int indexSize = sizeof(quint16);
+    Q_ASSERT(indicesCount < 65536);
+
+    QByteArray indicesBytes;
+    indicesBytes.resize(indicesCount * indexSize);
+    quint16 *indicesPtr = reinterpret_cast<quint16*>(indicesBytes.data());
+
+    createSidesIndices(indicesPtr, m_rings, m_slices);
+    createDiscIndices(indicesPtr, m_rings * (m_slices + 1), m_slices, -m_length * 0.5);
+    createDiscIndices(indicesPtr, m_rings * (m_slices + 1) + m_slices + 2, m_slices, m_length * 0.5);
+    Q_ASSERT(indicesPtr == (reinterpret_cast<quint16*>(indicesBytes.data()) + indicesCount));
+
+    return indicesBytes;
+}
+
 /*!
  * \qmltype CylinderGeometry
  * \instantiates Qt3DExtras::QCylinderGeometry
@@ -459,7 +398,7 @@ void QCylinderGeometry::updateVertices()
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_normalAttribute->setCount(nVerts);
 
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<CylinderVertexDataFunctor>::create(d->m_rings, d->m_slices, d->m_radius, d->m_length));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 /*!
@@ -470,7 +409,7 @@ void QCylinderGeometry::updateIndices()
     Q_D(QCylinderGeometry);
     const int faces = faceCount(d->m_slices, d->m_rings);
     d->m_indexAttribute->setCount(faces * 3);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<CylinderIndexDataFunctor>::create(d->m_rings, d->m_slices, d->m_length));
+    d->m_indexBuffer->setData(d->generateIndexData());
 }
 
 void QCylinderGeometry::setRings(int rings)
diff --git a/src/extras/geometries/qcylindergeometry_p.h b/src/extras/geometries/qcylindergeometry_p.h
index 50c37cb62..d88c34874 100644
--- a/src/extras/geometries/qcylindergeometry_p.h
+++ b/src/extras/geometries/qcylindergeometry_p.h
@@ -83,6 +83,9 @@ public:
     Qt3DRender::QAttribute *m_indexAttribute;
     Qt3DRender::QBuffer *m_vertexBuffer;
     Qt3DRender::QBuffer *m_indexBuffer;
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/extras/geometries/qcylindermesh.cpp b/src/extras/geometries/qcylindermesh.cpp
index 792944cd5..48e114cd4 100644
--- a/src/extras/geometries/qcylindermesh.cpp
+++ b/src/extras/geometries/qcylindermesh.cpp
@@ -46,7 +46,6 @@
 
 #include <Qt3DExtras/qcylindergeometry.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <QtGui/QVector3D>
 
diff --git a/src/extras/geometries/qplanegeometry.cpp b/src/extras/geometries/qplanegeometry.cpp
index 7c77f5028..a7ba3d56a 100644
--- a/src/extras/geometries/qplanegeometry.cpp
+++ b/src/extras/geometries/qplanegeometry.cpp
@@ -42,7 +42,6 @@
 
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 
 #include <limits>
 
@@ -146,71 +145,6 @@ QByteArray createPlaneIndexData(const QSize &resolution)
 
 } // anonymous
 
-class PlaneVertexBufferFunctor : public QBufferDataGenerator
-{
-public:
-    explicit PlaneVertexBufferFunctor(float w, float h, const QSize &resolution, bool mirrored)
-        : m_width(w)
-        , m_height(h)
-        , m_resolution(resolution)
-        , m_mirrored(mirrored)
-    {}
-
-    ~PlaneVertexBufferFunctor() {}
-
-    QByteArray operator()() final
-    {
-        return createPlaneVertexData(m_width, m_height, m_resolution, m_mirrored);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const final
-    {
-        const PlaneVertexBufferFunctor *otherFunctor = functor_cast<PlaneVertexBufferFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_width == m_width &&
-                    otherFunctor->m_height == m_height &&
-                    otherFunctor->m_resolution == m_resolution &&
-                    otherFunctor->m_mirrored == m_mirrored);
-        return false;
-    }
-
-    QT3D_FUNCTOR(PlaneVertexBufferFunctor)
-
-    private:
-        float m_width;
-    float m_height;
-    QSize m_resolution;
-    bool m_mirrored;
-};
-
-class PlaneIndexBufferFunctor : public QBufferDataGenerator
-{
-public:
-    explicit PlaneIndexBufferFunctor(const QSize &resolution)
-        : m_resolution(resolution)
-    {}
-
-    ~PlaneIndexBufferFunctor() {}
-
-    QByteArray operator()() final
-    {
-        return createPlaneIndexData(m_resolution);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const final
-    {
-        const PlaneIndexBufferFunctor *otherFunctor = functor_cast<PlaneIndexBufferFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_resolution == m_resolution);
-        return false;
-    }
-
-    QT3D_FUNCTOR(PlaneIndexBufferFunctor)
-
-    private:
-        QSize m_resolution;
-};
-
 /*!
  * \qmltype PlaneGeometry
  * \instantiates Qt3DExtras::QPlaneGeometry
@@ -330,7 +264,7 @@ void QPlaneGeometry::updateVertices()
     d->m_normalAttribute->setCount(nVerts);
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_tangentAttribute->setCount(nVerts);
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<PlaneVertexBufferFunctor>::create(d->m_width, d->m_height, d->m_meshResolution, d->m_mirrored));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 /*!
@@ -342,7 +276,7 @@ void QPlaneGeometry::updateIndices()
     const int faces = 2 * (d->m_meshResolution.width() - 1) * (d->m_meshResolution.height() - 1);
     // Each primitive has 3 vertices
     d->m_indexAttribute->setCount(faces * 3);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<PlaneIndexBufferFunctor>::create(d->m_meshResolution));
+    d->m_indexBuffer->setData(d->generateIndexData());
 
 }
 
@@ -560,8 +494,8 @@ void QPlaneGeometryPrivate::init()
     // Each primitive has 3 vertives
     m_indexAttribute->setCount(faces * 3);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<PlaneVertexBufferFunctor>::create(m_width, m_height, m_meshResolution, m_mirrored));
-    m_indexBuffer->setDataGenerator(QSharedPointer<PlaneIndexBufferFunctor>::create(m_meshResolution));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -570,6 +504,16 @@ void QPlaneGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QPlaneGeometryPrivate::generateVertexData() const
+{
+    return createPlaneVertexData(m_width, m_height, m_meshResolution, m_mirrored);
+}
+
+QByteArray QPlaneGeometryPrivate::generateIndexData() const
+{
+    return createPlaneIndexData(m_meshResolution);
+}
+
 } //  Qt3DExtras
 
 QT_END_NAMESPACE
diff --git a/src/extras/geometries/qplanegeometry_p.h b/src/extras/geometries/qplanegeometry_p.h
index 68d979895..b1f63f277 100644
--- a/src/extras/geometries/qplanegeometry_p.h
+++ b/src/extras/geometries/qplanegeometry_p.h
@@ -85,6 +85,9 @@ public:
     Qt3DRender::QBuffer *m_indexBuffer;
 
     Q_DECLARE_PUBLIC(QPlaneGeometry)
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/extras/geometries/qspheregeometry.cpp b/src/extras/geometries/qspheregeometry.cpp
index f5ec6bec2..ab84b5ff0 100644
--- a/src/extras/geometries/qspheregeometry.cpp
+++ b/src/extras/geometries/qspheregeometry.cpp
@@ -40,7 +40,6 @@
 #include "qspheregeometry.h"
 #include "qspheregeometry_p.h"
 
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qbuffer.h>
 #include <Qt3DRender/qattribute.h>
 
@@ -167,69 +166,6 @@ QByteArray createSphereMeshIndexData(int rings, int slices)
 
 } // anonymous
 
-class SphereVertexDataFunctor : public QBufferDataGenerator
-{
-public:
-    SphereVertexDataFunctor(int rings, int slices, float radius)
-        : m_rings(rings)
-        , m_slices(slices)
-        , m_radius(radius)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        return createSphereMeshVertexData(m_radius, m_rings, m_slices);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const SphereVertexDataFunctor *otherFunctor = functor_cast<SphereVertexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_radius == m_radius);
-        return false;
-    }
-
-    QT3D_FUNCTOR(SphereVertexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-    float m_radius;
-};
-
-class SphereIndexDataFunctor : public QBufferDataGenerator
-{
-public:
-    SphereIndexDataFunctor(int rings, int slices)
-        : m_rings(rings)
-        , m_slices(slices)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        return createSphereMeshIndexData(m_rings, m_slices);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const SphereIndexDataFunctor *otherFunctor = functor_cast<SphereIndexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices);
-        return false;
-    }
-
-    QT3D_FUNCTOR(SphereIndexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-};
-
 QSphereGeometryPrivate::QSphereGeometryPrivate()
     : QGeometryPrivate()
     , m_generateTangents(false)
@@ -304,8 +240,8 @@ void QSphereGeometryPrivate::init()
 
     m_indexAttribute->setCount(faces * 3);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<SphereVertexDataFunctor>::create(m_rings, m_slices, m_radius));
-    m_indexBuffer->setDataGenerator(QSharedPointer<SphereIndexDataFunctor>::create(m_rings, m_slices));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -315,6 +251,16 @@ void QSphereGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QSphereGeometryPrivate::generateVertexData() const
+{
+    return createSphereMeshVertexData(m_radius, m_rings, m_slices);
+}
+
+QByteArray QSphereGeometryPrivate::generateIndexData() const
+{
+    return createSphereMeshIndexData(m_rings, m_slices);
+}
+
 /*!
  * \qmltype SphereGeometry
  * \instantiates Qt3DExtras::QSphereGeometry
@@ -432,7 +378,7 @@ void QSphereGeometry::updateVertices()
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_normalAttribute->setCount(nVerts);
     d->m_tangentAttribute->setCount(nVerts);
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<SphereVertexDataFunctor>::create(d->m_rings, d->m_slices, d->m_radius));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 /*!
@@ -443,8 +389,7 @@ void QSphereGeometry::updateIndices()
     Q_D(QSphereGeometry);
     const int faces = (d->m_slices * 2) * (d->m_rings - 2) + (2 * d->m_slices);
     d->m_indexAttribute->setCount(faces * 3);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<SphereIndexDataFunctor>::create(d->m_rings, d->m_slices));
-
+    d->m_indexBuffer->setData(d->generateIndexData());
 }
 
 void QSphereGeometry::setRings(int rings)
diff --git a/src/extras/geometries/qspheregeometry_p.h b/src/extras/geometries/qspheregeometry_p.h
index dc96766e1..2dc83495e 100644
--- a/src/extras/geometries/qspheregeometry_p.h
+++ b/src/extras/geometries/qspheregeometry_p.h
@@ -83,6 +83,9 @@ public:
     Qt3DRender::QBuffer *m_indexBuffer;
 
     Q_DECLARE_PUBLIC(QSphereGeometry);
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/extras/geometries/qtorusgeometry.cpp b/src/extras/geometries/qtorusgeometry.cpp
index 98707b03c..1e65ab2ef 100644
--- a/src/extras/geometries/qtorusgeometry.cpp
+++ b/src/extras/geometries/qtorusgeometry.cpp
@@ -41,7 +41,6 @@
 #include "qtorusgeometry_p.h"
 
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qattribute.h>
 #include <QtGui/QVector3D>
 #include <QtGui/QVector4D>
@@ -153,72 +152,6 @@ QByteArray createTorusIndexData(int requestedRings, int requestedSlices)
 
 } // anonymous
 
-class TorusVertexDataFunctor : public QBufferDataGenerator
-{
-public:
-    TorusVertexDataFunctor(int rings, int slices, float radius, float minorRadius)
-        : m_rings(rings)
-        , m_slices(slices)
-        , m_radius(radius)
-        , m_minorRadius(minorRadius)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        return createTorusVertexData(m_radius, m_minorRadius, m_rings, m_slices);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const TorusVertexDataFunctor *otherFunctor = functor_cast<TorusVertexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices &&
-                    otherFunctor->m_radius == m_radius &&
-                    otherFunctor->m_minorRadius == m_minorRadius);
-        return false;
-    }
-
-    QT3D_FUNCTOR(TorusVertexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-    float m_radius;
-    float m_minorRadius;
-};
-
-class TorusIndexDataFunctor : public QBufferDataGenerator
-{
-public:
-    TorusIndexDataFunctor(int rings, int slices)
-        : m_rings(rings)
-        , m_slices(slices)
-    {
-    }
-
-    QByteArray operator ()() override
-    {
-        return createTorusIndexData(m_rings, m_slices);
-    }
-
-    bool operator ==(const QBufferDataGenerator &other) const override
-    {
-        const TorusIndexDataFunctor *otherFunctor = functor_cast<TorusIndexDataFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return (otherFunctor->m_rings == m_rings &&
-                    otherFunctor->m_slices == m_slices);
-        return false;
-    }
-
-    QT3D_FUNCTOR(TorusIndexDataFunctor)
-
-private:
-    int m_rings;
-    int m_slices;
-};
-
 QTorusGeometryPrivate::QTorusGeometryPrivate()
     : QGeometryPrivate()
     , m_rings(16)
@@ -292,8 +225,8 @@ void QTorusGeometryPrivate::init()
 
     m_indexAttribute->setCount(triangles * 3);
 
-    m_vertexBuffer->setDataGenerator(QSharedPointer<TorusVertexDataFunctor>::create(m_rings, m_slices, m_radius, m_minorRadius));
-    m_indexBuffer->setDataGenerator(QSharedPointer<TorusIndexDataFunctor>::create(m_rings, m_slices));
+    m_vertexBuffer->setData(generateVertexData());
+    m_indexBuffer->setData(generateIndexData());
 
     q->addAttribute(m_positionAttribute);
     q->addAttribute(m_texCoordAttribute);
@@ -302,6 +235,16 @@ void QTorusGeometryPrivate::init()
     q->addAttribute(m_indexAttribute);
 }
 
+QByteArray QTorusGeometryPrivate::generateVertexData() const
+{
+    return createTorusVertexData(m_radius, m_minorRadius, m_rings, m_slices);
+}
+
+QByteArray QTorusGeometryPrivate::generateIndexData() const
+{
+    return createTorusIndexData(m_rings, m_slices);
+}
+
 /*!
  * \qmltype TorusGeometry
  * \instantiates Qt3DExtras::QTorusGeometry
@@ -411,7 +354,7 @@ void QTorusGeometry::updateVertices()
     d->m_positionAttribute->setCount(nVerts);
     d->m_texCoordAttribute->setCount(nVerts);
     d->m_normalAttribute->setCount(nVerts);
-    d->m_vertexBuffer->setDataGenerator(QSharedPointer<TorusVertexDataFunctor>::create(d->m_rings, d->m_slices, d->m_radius, d->m_minorRadius));
+    d->m_vertexBuffer->setData(d->generateVertexData());
 }
 
 /*!
@@ -422,7 +365,7 @@ void QTorusGeometry::updateIndices()
     Q_D(QTorusGeometry);
     const int triangles = triangleCount(d->m_rings, d->m_slices);
     d->m_indexAttribute->setCount(triangles * 3);
-    d->m_indexBuffer->setDataGenerator(QSharedPointer<TorusIndexDataFunctor>::create(d->m_rings, d->m_slices));
+    d->m_indexBuffer->setData(d->generateIndexData());
 }
 
 void QTorusGeometry::setRings(int rings)
diff --git a/src/extras/geometries/qtorusgeometry_p.h b/src/extras/geometries/qtorusgeometry_p.h
index 7506a95ac..c05e03835 100644
--- a/src/extras/geometries/qtorusgeometry_p.h
+++ b/src/extras/geometries/qtorusgeometry_p.h
@@ -83,6 +83,9 @@ public:
     Qt3DRender::QBuffer *m_indexBuffer;
 
     Q_DECLARE_PUBLIC(QTorusGeometry)
+
+    QByteArray generateVertexData() const;
+    QByteArray generateIndexData() const;
 };
 
 } // Qt3DExtras
diff --git a/src/plugins/renderers/opengl/renderer/renderer.cpp b/src/plugins/renderers/opengl/renderer/renderer.cpp
index cc49697fd..a50a770eb 100644
--- a/src/plugins/renderers/opengl/renderer/renderer.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderer.cpp
@@ -74,7 +74,6 @@
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/techniquemanager_p.h>
 #include <Qt3DRender/private/platformsurfacefilter_p.h>
-#include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/rendercapture_p.h>
 #include <Qt3DRender/private/updatelevelofdetailjob_p.h>
 #include <Qt3DRender/private/buffercapture_p.h>
@@ -1895,17 +1894,11 @@ QVector<QAspectJobPtr> Renderer::preRenderingJobs()
 QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
 {
     QVector<QAspectJobPtr> renderBinJobs;
-    // Create the jobs to build the frame
-    const QVector<QAspectJobPtr> bufferJobs = createRenderBufferJobs();
 
     // Remove previous dependencies
     m_calculateBoundingVolumeJob->removeDependency(QWeakPointer<QAspectJob>());
     m_cleanupJob->removeDependency(QWeakPointer<QAspectJob>());
 
-    // Set dependencies
-    for (const QAspectJobPtr &bufferJob : bufferJobs)
-        m_calculateBoundingVolumeJob->addDependency(bufferJob);
-
     m_updateLevelOfDetailJob->setFrameGraphRoot(frameGraphRoot());
 
     const BackendNodeDirtySet dirtyBitsForFrame = m_dirtyBits.marked | m_dirtyBits.remaining;
@@ -1945,7 +1938,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     renderBinJobs.push_back(m_updateSkinningPaletteJob);
     renderBinJobs.push_back(m_updateLevelOfDetailJob);
     renderBinJobs.push_back(m_cleanupJob);
-    renderBinJobs.append(bufferJobs);
 
     // Jobs to prepare GL Resource upload
     renderBinJobs.push_back(m_vaoGathererJob);
@@ -2429,27 +2421,6 @@ SubmissionContext *Renderer::submissionContext() const
     return m_submissionContext.data();
 }
 
-// Returns a vector of jobs to be performed for dirty buffers
-// 1 dirty buffer == 1 job, all job can be performed in parallel
-QVector<Qt3DCore::QAspectJobPtr> Renderer::createRenderBufferJobs() const
-{
-    const QVector<QNodeId> dirtyBuffers = m_nodesManager->bufferManager()->takeDirtyBuffers();
-    QVector<QAspectJobPtr> dirtyBuffersJobs;
-    dirtyBuffersJobs.reserve(dirtyBuffers.size());
-
-    for (const QNodeId bufId : dirtyBuffers) {
-        Render::HBuffer bufferHandle = m_nodesManager->lookupHandle<Render::Buffer, Render::BufferManager, Render::HBuffer>(bufId);
-        if (!bufferHandle.isNull()) {
-            // Create new buffer job
-            auto job = Render::LoadBufferJobPtr::create(bufferHandle);
-            job->setNodeManager(m_nodesManager);
-            dirtyBuffersJobs.push_back(job);
-        }
-    }
-
-    return dirtyBuffersJobs;
-}
-
 } // namespace OpenGL
 } // namespace Render
 } // namespace Qt3DRender
diff --git a/src/plugins/renderers/opengl/renderer/renderer_p.h b/src/plugins/renderers/opengl/renderer/renderer_p.h
index 8c3a252bb..5999aabe3 100644
--- a/src/plugins/renderers/opengl/renderer/renderer_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderer_p.h
@@ -232,8 +232,6 @@ public:
     Qt3DCore::QAspectJobPtr syncLoadingJobs() override;
     Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() override;
 
-    QVector<Qt3DCore::QAspectJobPtr> createRenderBufferJobs() const;
-
     inline FrameCleanupJobPtr frameCleanupJob() const { return m_cleanupJob; }
     inline UpdateShaderDataTransformJobPtr updateShaderDataTransformJob() const { return m_updateShaderDataTransformJob; }
     inline CalculateBoundingVolumeJobPtr calculateBoundingVolumeJob() const { return m_calculateBoundingVolumeJob; }
diff --git a/src/plugins/sceneparsers/gltfexport/gltfexporter.cpp b/src/plugins/sceneparsers/gltfexport/gltfexporter.cpp
index 0f9a3bef9..9fced8e89 100644
--- a/src/plugins/sceneparsers/gltfexport/gltfexporter.cpp
+++ b/src/plugins/sceneparsers/gltfexport/gltfexporter.cpp
@@ -66,7 +66,6 @@
 #include <Qt3DRender/qeffect.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qmaterial.h>
 #include <Qt3DRender/qgraphicsapifilter.h>
 #include <Qt3DRender/qparameter.h>
@@ -77,7 +76,6 @@
 #include <Qt3DRender/qdirectionallight.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DRender/qtechnique.h>
 #include <Qt3DRender/qalphacoverage.h>
 #include <Qt3DRender/qalphatest.h>
@@ -779,15 +777,7 @@ void GLTFExporter::parseMeshes()
             }
         } else {
             meshInfo.meshComponent = nullptr;
-            QGeometry *meshGeometry = nullptr;
-            QGeometryFactoryPtr geometryFunctorPtr = mesh->geometryFactory();
-            if (!geometryFunctorPtr.data()) {
-                meshGeometry = mesh->geometry();
-            } else {
-                // Execute the geometry functor to get the geometry, if it is available.
-                // Functor gives us the latest data if geometry has changed.
-                meshGeometry = geometryFunctorPtr.data()->operator()();
-            }
+            QGeometry *meshGeometry = mesh->geometry();
 
             if (!meshGeometry) {
                 qCWarning(GLTFExporterLog, "Ignoring mesh without geometry!");
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 61567854f..fa6416199 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -499,7 +499,7 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
     // Create jobs that will get executed by the threadpool
     QVector<QAspectJobPtr> jobs;
 
-    // 1 LoadBufferJobs, GeometryJobs, SceneLoaderJobs, LoadTextureJobs
+    // 1 GeometryJobs, SceneLoaderJobs, LoadTextureJobs
     // 2 CalculateBoundingVolumeJob (depends on LoadBuffer)
     // 3 WorldTransformJob
     // 4 UpdateBoundingVolume, FramePreparationJob (depend on WorlTransformJob)
diff --git a/src/render/geometry/buffer.cpp b/src/render/geometry/buffer.cpp
index 3ffcd25bc..4d3d5c1aa 100644
--- a/src/render/geometry/buffer.cpp
+++ b/src/render/geometry/buffer.cpp
@@ -69,7 +69,6 @@ void Buffer::cleanup()
     m_usage = QBuffer::StaticDraw;
     m_data.clear();
     m_bufferUpdates.clear();
-    m_functor.reset();
     m_bufferDirty = false;
     m_syncData = false;
     m_access = QBuffer::Write;
@@ -81,14 +80,6 @@ void Buffer::setManager(BufferManager *manager)
     m_manager = manager;
 }
 
-void Buffer::executeFunctor()
-{
-    Q_ASSERT(m_functor);
-    m_data = (*m_functor)();
-    // Request data to be loaded
-    forceDataUpload();
-}
-
 //Called from th sendBufferJob
 void Buffer::updateDataFromGPUToCPU(QByteArray data)
 {
@@ -126,16 +117,6 @@ void Buffer::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
         m_bufferDirty = true;
     }
     {
-        QBufferDataGeneratorPtr newGenerator = node->dataGenerator();
-        bool dirty = (newGenerator && m_functor && !(*newGenerator == *m_functor)) ||
-                     (newGenerator.isNull() && !m_functor.isNull()) ||
-                     (!newGenerator.isNull() && m_functor.isNull());
-        m_bufferDirty |= dirty;
-        m_functor = newGenerator;
-        if (m_functor && m_manager != nullptr)
-            m_manager->addDirtyBuffer(peerId());
-    }
-    {
         const QVariant v = node->property("QT3D_updateData");
 
         // Make sure we record data if it's the first time we are called
diff --git a/src/render/geometry/buffer_p.h b/src/render/geometry/buffer_p.h
index ed51c01d8..41a525fc2 100644
--- a/src/render/geometry/buffer_p.h
+++ b/src/render/geometry/buffer_p.h
@@ -54,7 +54,6 @@
 #include <QtCore>
 #include <Qt3DRender/private/backendnode_p.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -76,13 +75,11 @@ public:
     void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void setManager(BufferManager *manager);
-    void executeFunctor();
     void updateDataFromGPUToCPU(QByteArray data);
     inline QBuffer::UsageType usage() const { return m_usage; }
     inline QByteArray data() const { return m_data; }
     inline QVector<Qt3DRender::QBufferUpdate> &pendingBufferUpdates() { return m_bufferUpdates; }
     inline bool isDirty() const { return m_bufferDirty; }
-    inline QBufferDataGeneratorPtr dataGenerator() const { return m_functor; }
     inline bool isSyncData() const { return m_syncData; }
     inline QBuffer::AccessType access() const { return m_access; }
     void unsetDirty();
@@ -96,7 +93,6 @@ private:
     bool m_bufferDirty;
     bool m_syncData;
     QBuffer::AccessType m_access;
-    QBufferDataGeneratorPtr m_functor;
     BufferManager *m_manager;
 };
 
diff --git a/src/render/geometry/geometry.pri b/src/render/geometry/geometry.pri
index 63a18f24e..efc245fba 100644
--- a/src/render/geometry/geometry.pri
+++ b/src/render/geometry/geometry.pri
@@ -18,7 +18,6 @@ HEADERS += \
     $$PWD/qmesh_p.h \
     $$PWD/qattribute_p.h \
     $$PWD/qattribute.h \
-    $$PWD/qbufferdatagenerator.h \
     $$PWD/armature_p.h \
     $$PWD/skeleton_p.h \
     $$PWD/gltfskeletonloader_p.h \
diff --git a/src/render/geometry/qbuffer.cpp b/src/render/geometry/qbuffer.cpp
index 646670ad1..dc2833158 100644
--- a/src/render/geometry/qbuffer.cpp
+++ b/src/render/geometry/qbuffer.cpp
@@ -109,12 +109,7 @@ void QBufferPrivate::setData(const QByteArray &data)
  * \brief Provides a data store for raw data to later be used as vertices or
  * uniforms.
  *
- * Data can either be provided directly using QBuffer::setData() or by
- * specifying a generator with QBuffer::setDataGenerator() and providing a
- * Qt3DRender::QBufferDataGeneratorPtr.
- *
- * When using a generator the data will be loaded asynchronously in a job. The
- * loaded data can be read back if the QBuffer::syncData flag is set to true.
+ * Data can be provided directly using QBuffer::setData().
  */
 
 /*!
@@ -130,93 +125,6 @@ void QBufferPrivate::setData(const QByteArray &data)
  */
 
 /*!
-    \class Qt3DRender::QBufferDataGenerator
-    \inmodule Qt3DRender
-
-    \inherits Qt3DRender::QAbstractFunctor
-
-    \brief Provides a mechanism to generate buffer data from a job.
-
-    The Qt3DRender::QBufferDataGenerator should be subclassed to provide a way
-    to fill the data of a Qt3DRender::QBuffer. Such functors are executed at
-    runtime in a Qt 3D job (likely in parallel with many other jobs). When
-    providing a functor you must implement the operator() which will be called
-    to generate the actual data. You must make sure that you have stored copies
-    of anything you might need for it to execute properly. You should also
-    implement the operator==. It will be used to compare with other functors
-    and based on that allow the renderer to decide if a new functor should be
-    executed or not.
-
-    \note functors are useful when you can build data from a few set of
-    attributes (e.g: building a sphere from a radius property). If you already
-    have access to the buffer data, using Qt3DRender::QBuffer::setData() is
-    likely more efficient.
-
-    \code
-
-    QByteArray createSphereMeshVertexData(float radius, int rings, int slices)
-    {
-        ...
-    }
-
-    class SphereVertexDataFunctor : public QBufferDataGenerator
-    {
-    public:
-        SphereVertexDataFunctor(int rings, int slices, float radius)
-            : m_rings(rings)
-            , m_slices(slices)
-            , m_radius(radius)
-        {}
-
-        QByteArray operator ()() override
-        {
-            return createSphereMeshVertexData(m_radius, m_rings, m_slices);
-        }
-
-        bool operator ==(const QBufferDataGenerator &other) const override
-        {
-            const SphereVertexDataFunctor *otherFunctor = functor_cast<SphereVertexDataFunctor>(&other);
-            if (otherFunctor != nullptr)
-                return (otherFunctor->m_rings == m_rings &&
-                        otherFunctor->m_slices == m_slices &&
-                        otherFunctor->m_radius == m_radius);
-            return false;
-        }
-
-        QT3D_FUNCTOR(SphereVertexDataFunctor)
-
-    private:
-        int m_rings;
-        int m_slices;
-        float m_radius;
-    };
-
-    \endcode
-
-    The QT3D_FUNCTOR macro should be added when subclassing. This allows you to
-    use functor_cast in your comparison operator to make sure that the other
-    functor is of the same type as the one your are trying to compare against.
-*/
-
-/*!
-    \fn Qt3DRender::QBufferDataGenerator::operator()()
-
-    Should be implemented to return the buffer data as a QByteArray when called.
-  */
-
-/*!
-    \fn Qt3DRender::QBufferDataGenerator::operator ==(const QBufferDataGenerator &other) const
-
-    Should be reimplemented to return true when two generators (the one you are
-    comparing against and the \a other generator) are identical,
-    false otherwise.
-
-    \note The renderer uses this comparison to decide whether data for a buffer
-    needs to be reuploaded or not when the functor on a Qt3DRender::QBuffer
-    changes.
- */
-
-/*!
  * \enum QBuffer::BufferType
  *
  * The type of the buffer.
@@ -383,27 +291,6 @@ QBuffer::BufferType QBuffer::type() const
 }
 
 /*!
- * Sets the buffer \a functor.
- */
-void QBuffer::setDataGenerator(const QBufferDataGeneratorPtr &functor)
-{
-    Q_D(QBuffer);
-    if (functor && d->m_functor && *functor == *d->m_functor)
-        return;
-    d->m_functor = functor;
-    d->update();
-}
-
-/*!
- * \return the buffer functor.
- */
-QBufferDataGeneratorPtr QBuffer::dataGenerator() const
-{
-    Q_D(const QBuffer);
-    return d->m_functor;
-}
-
-/*!
  * \property QBuffer::syncData
  *
  * Holds the syncData flag. When syncData is true, this will force data created
diff --git a/src/render/geometry/qbuffer.h b/src/render/geometry/qbuffer.h
index 6b18063ee..a4de25eae 100644
--- a/src/render/geometry/qbuffer.h
+++ b/src/render/geometry/qbuffer.h
@@ -50,8 +50,6 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 class QBufferPrivate;
-class QBufferDataGenerator;
-typedef QSharedPointer<QBufferDataGenerator> QBufferDataGeneratorPtr;
 
 class Q_3DRENDERSHARED_EXPORT QBuffer : public Qt3DCore::QNode
 {
@@ -107,9 +105,6 @@ public:
     void setData(const QByteArray &bytes);
     QByteArray data() const;
 
-    Q3D_DECL_DEPRECATED void setDataGenerator(const QBufferDataGeneratorPtr &functor);
-    Q3D_DECL_DEPRECATED QBufferDataGeneratorPtr dataGenerator() const;
-
     Q_INVOKABLE void updateData(int offset, const QByteArray &bytes);
 
 public Q_SLOTS:
diff --git a/src/render/geometry/qbuffer_p.h b/src/render/geometry/qbuffer_p.h
index 0b948cff3..082249d3c 100644
--- a/src/render/geometry/qbuffer_p.h
+++ b/src/render/geometry/qbuffer_p.h
@@ -53,7 +53,6 @@
 
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qt3drender_global.h>
 #include <private/qnode_p.h>
 #include <QByteArray>
@@ -72,7 +71,6 @@ public:
     QByteArray m_data;
     QBuffer::BufferType m_type;
     QBuffer::UsageType m_usage;
-    QBufferDataGeneratorPtr m_functor;
     bool m_syncData;
     QBuffer::AccessType m_access;
 
diff --git a/src/render/geometry/qbufferdatagenerator.h b/src/render/geometry/qbufferdatagenerator.h
deleted file mode 100644
index aea6eaef5..000000000
--- a/src/render/geometry/qbufferdatagenerator.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QT3DRENDER_QBUFFERDATAGENERATOR
-#define QT3DRENDER_QBUFFERDATAGENERATOR
-
-#include <Qt3DRender/qt3drender_global.h>
-#include <Qt3DRender/qabstractfunctor.h>
-#include <QtCore/QSharedPointer>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DRender {
-
-class Q_3DRENDERSHARED_EXPORT QBufferDataGenerator : public QAbstractFunctor
-{
-public:
-    virtual ~QBufferDataGenerator() {}
-    virtual QByteArray operator()() = 0;
-    virtual bool operator ==(const QBufferDataGenerator &other) const = 0;
-};
-
-typedef QSharedPointer<QBufferDataGenerator> QBufferDataGeneratorPtr;
-
-} // namespace Qt3DRender
-
-QT_END_NAMESPACE
-
-Q_DECLARE_METATYPE(Qt3DRender::QBufferDataGeneratorPtr) // LCOV_EXCL_LINE
-
-#endif // QT3DRENDER_QBUFFERDATAGENERATOR
-
diff --git a/src/render/jobs/jobs.pri b/src/render/jobs/jobs.pri
index 07d6f4799..97ad32557 100644
--- a/src/render/jobs/jobs.pri
+++ b/src/render/jobs/jobs.pri
@@ -4,7 +4,6 @@ HEADERS += \
     $$PWD/updateworldtransformjob_p.h \
     $$PWD/loadscenejob_p.h \
     $$PWD/framecleanupjob_p.h \
-    $$PWD/loadbufferjob_p.h \
     $$PWD/loadgeometryjob_p.h \
     $$PWD/calcboundingvolumejob_p.h \
     $$PWD/pickboundingvolumejob_p.h \
@@ -34,7 +33,6 @@ SOURCES += \
     $$PWD/updateworldtransformjob.cpp \
     $$PWD/loadscenejob.cpp \
     $$PWD/framecleanupjob.cpp \
-    $$PWD/loadbufferjob.cpp \
     $$PWD/loadgeometryjob.cpp \
     $$PWD/calcboundingvolumejob.cpp \
     $$PWD/pickboundingvolumejob.cpp \
diff --git a/tests/auto/extras/common/geometrytesthelper.h b/tests/auto/extras/common/geometrytesthelper.h
index 5b04a078b..b825fa407 100644
--- a/tests/auto/extras/common/geometrytesthelper.h
+++ b/tests/auto/extras/common/geometrytesthelper.h
@@ -31,36 +31,8 @@
 
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DRender/qgeometry.h>
 
-inline void generateGeometry(Qt3DRender::QGeometry &geometry)
-{
-    // Get all attributes
-    const QVector<Qt3DRender::QAttribute *> attributes = geometry.attributes();
-
-    // Get all unique data generators from the buffers referenced by the attributes
-    QHash<Qt3DRender::QBufferDataGeneratorPtr, Qt3DRender::QBuffer *> dataGenerators;
-    for (const auto attribute : attributes) {
-        QT_WARNING_PUSH
-        QT_WARNING_DISABLE_DEPRECATED
-        const auto dataGenerator = attribute->buffer()->dataGenerator();
-        if (!dataGenerators.contains(dataGenerator))
-            dataGenerators.insert(dataGenerator, attribute->buffer());
-        QT_WARNING_POP
-    }
-
-    // Generate data for each buffer
-    const auto end = dataGenerators.end();
-    for (auto it = dataGenerators.begin(); it != end; ++it) {
-        Qt3DRender::QBufferDataGeneratorPtr dataGenerator = it.key();
-        const QByteArray data = (*dataGenerator)();
-
-        Qt3DRender::QBuffer *buffer = it.value();
-        buffer->setData(data);
-    }
-}
-
 template<typename IndexType>
 IndexType extractIndexData(Qt3DRender::QAttribute *attribute, int index)
 {
diff --git a/tests/auto/extras/qcuboidgeometry/tst_qcuboidgeometry.cpp b/tests/auto/extras/qcuboidgeometry/tst_qcuboidgeometry.cpp
index 838e5dea9..f20b1e870 100644
--- a/tests/auto/extras/qcuboidgeometry/tst_qcuboidgeometry.cpp
+++ b/tests/auto/extras/qcuboidgeometry/tst_qcuboidgeometry.cpp
@@ -31,7 +31,6 @@
 #include <Qt3DExtras/qcuboidgeometry.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <qopenglcontext.h>
 #include <QtGui/qvector2d.h>
 #include <QtGui/qvector3d.h>
@@ -542,8 +541,6 @@ private Q_SLOTS:
         geometry.setYZMeshResolution(yzMeshResolution);
         geometry.setXZMeshResolution(xzMeshResolution);
 
-        generateGeometry(geometry);
-
         // THEN
 
         // Check buffer of each attribute is valid and actually has some data
diff --git a/tests/auto/extras/qtorusgeometry/tst_qtorusgeometry.cpp b/tests/auto/extras/qtorusgeometry/tst_qtorusgeometry.cpp
index bf5651c9c..7a6965f20 100644
--- a/tests/auto/extras/qtorusgeometry/tst_qtorusgeometry.cpp
+++ b/tests/auto/extras/qtorusgeometry/tst_qtorusgeometry.cpp
@@ -31,7 +31,6 @@
 #include <Qt3DExtras/qtorusgeometry.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <qopenglcontext.h>
 #include <QtGui/qvector2d.h>
 #include <QtGui/qvector3d.h>
@@ -317,8 +316,6 @@ private Q_SLOTS:
         geometry.setRadius(radius);
         geometry.setMinorRadius(minorRadius);
 
-        generateGeometry(geometry);
-
         // THEN
 
         // Check buffer of each attribute is valid and actually has some data
diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index 4645a7c02..6c5473cff 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -53,7 +53,6 @@
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
 #include <Qt3DRender/private/expandboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/sphere_p.h>
@@ -160,14 +159,6 @@ void runRequiredJobs(Qt3DRender::TestAspect *test)
     updateWorldTransform.setManagers(test->nodeManagers());
     updateWorldTransform.run();
 
-    // For each buffer
-    QVector<Qt3DRender::Render::HBuffer> bufferHandles = test->nodeManagers()->bufferManager()->activeHandles();
-    for (auto bufferHandle : bufferHandles) {
-        Qt3DRender::Render::LoadBufferJob loadBuffer(bufferHandle);
-        loadBuffer.setNodeManager(test->nodeManagers());
-        loadBuffer.run();
-    }
-
     Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
     calcBVolume.setManagers(test->nodeManagers());
     calcBVolume.setRoot(test->sceneRoot());
diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp
index c021ea805..25c4a9633 100644
--- a/tests/auto/render/buffer/tst_buffer.cpp
+++ b/tests/auto/render/buffer/tst_buffer.cpp
@@ -39,32 +39,6 @@ QT_WARNING_DISABLE_DEPRECATED
 #include "testarbiter.h"
 #include "testrenderer.h"
 
-class TestFunctor : public Qt3DRender::QBufferDataGenerator
-{
-public:
-    explicit TestFunctor(int size)
-        : m_size(size)
-    {}
-
-    QByteArray operator ()() final
-    {
-        return QByteArrayLiteral("454");
-    }
-
-    bool operator ==(const Qt3DRender::QBufferDataGenerator &other) const final
-    {
-        const TestFunctor *otherFunctor = Qt3DRender::functor_cast<TestFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return otherFunctor->m_size == m_size;
-        return false;
-    }
-
-    QT3D_FUNCTOR(TestFunctor)
-
-private:
-    int m_size;
-};
-
 class tst_RenderBuffer : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
@@ -81,7 +55,6 @@ private Q_SLOTS:
 
         buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         buffer.setData(QByteArrayLiteral("Corvette"));
-        buffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(883)));
 
         // WHEN
         renderBuffer.setRenderer(&renderer);
@@ -93,8 +66,6 @@ private Q_SLOTS:
         QCOMPARE(renderBuffer.isDirty(), true);
         QCOMPARE(renderBuffer.usage(), buffer.usage());
         QCOMPARE(renderBuffer.data(), buffer.data());
-        QCOMPARE(renderBuffer.dataGenerator(), buffer.dataGenerator());
-        QVERIFY(*renderBuffer.dataGenerator() == *buffer.dataGenerator());
         QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1);
         QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1);
     }
@@ -111,7 +82,6 @@ private Q_SLOTS:
         QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
         QVERIFY(backendBuffer.data().isEmpty());
         QVERIFY(backendBuffer.peerId().isNull());
-        QVERIFY(backendBuffer.dataGenerator().isNull());
         QVERIFY(backendBuffer.pendingBufferUpdates().empty());
 
         // GIVEN
@@ -126,20 +96,17 @@ private Q_SLOTS:
         QCOMPARE(backendBuffer.isDirty(), true);
         QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
         QVERIFY(backendBuffer.data().isEmpty());
-        QVERIFY(backendBuffer.dataGenerator().isNull());
         QVERIFY(backendBuffer.pendingBufferUpdates().empty());
 
         // WHEN
         frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         frontendBuffer.setData(QByteArrayLiteral("C7KR4"));
-        frontendBuffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73)));
         backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
         QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::DynamicCopy);
         QCOMPARE(backendBuffer.isDirty(), true);
         QCOMPARE(backendBuffer.data(), QByteArrayLiteral("C7KR4"));
-        QVERIFY(!backendBuffer.dataGenerator().isNull());
         QVERIFY(!backendBuffer.pendingBufferUpdates().empty());
 
         // WHEN
@@ -156,7 +123,6 @@ private Q_SLOTS:
         QCOMPARE(backendBuffer.isDirty(), false);
         QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
         QVERIFY(backendBuffer.data().isEmpty());
-        QVERIFY(backendBuffer.dataGenerator().isNull());
         QVERIFY(backendBuffer.pendingBufferUpdates().empty());
     }
 
@@ -264,21 +230,6 @@ private Q_SLOTS:
         QVERIFY(!backendBuffer.isDirty());
 
         // WHEN
-        Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355));
-        frontendBuffer.setDataGenerator(functor);
-        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
-
-        // THEN
-        QCOMPARE(backendBuffer.dataGenerator(), functor);
-        QVERIFY(backendBuffer.isDirty());
-
-        QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
-        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-
-        backendBuffer.unsetDirty();
-        QVERIFY(!backendBuffer.isDirty());
-
-        // WHEN
         frontendBuffer.setSyncData(true);
         backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
@@ -290,17 +241,6 @@ private Q_SLOTS:
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         // WHEN
-        TestArbiter arbiter;
-        backendBuffer.executeFunctor();
-
-        // THEN
-        QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1);
-        QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1);
-
-        arbiter.clear();
-        backendBuffer.pendingBufferUpdates().clear();
-
-        // WHEN
         frontendBuffer.updateData(2, QByteArrayLiteral("LS5"));
         backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index e84be5815..ea809cf50 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -59,7 +59,6 @@
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
 #include <Qt3DRender/private/expandboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/qobjectpicker_p.h>
@@ -181,14 +180,6 @@ void runRequiredJobs(Qt3DRender::TestAspect *test)
     updateWorldTransform.setManagers(test->nodeManagers());
     updateWorldTransform.run();
 
-    // For each buffer
-    QVector<Qt3DRender::Render::HBuffer> bufferHandles = test->nodeManagers()->bufferManager()->activeHandles();
-    for (auto bufferHandle : bufferHandles) {
-        Qt3DRender::Render::LoadBufferJob loadBuffer(bufferHandle);
-        loadBuffer.setNodeManager(test->nodeManagers());
-        loadBuffer.run();
-    }
-
     Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
     calcBVolume.setManagers(test->nodeManagers());
     calcBVolume.setRoot(test->sceneRoot());
diff --git a/tests/auto/render/picking/tst_picking.cpp b/tests/auto/render/picking/tst_picking.cpp
index d9800c24f..acc9664bf 100644
--- a/tests/auto/render/picking/tst_picking.cpp
+++ b/tests/auto/render/picking/tst_picking.cpp
@@ -38,7 +38,6 @@
 #include <Qt3DExtras/qspheremesh.h>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 #include <Qt3DExtras/qspheregeometry.h>
 #include <Qt3DRender/qpickevent.h>
 
@@ -75,13 +74,6 @@ public:
         QAttribute *positionAttr = static_cast<QAttribute *>(g->attributes().first());
         Qt3DRender::QBuffer *vertexBuffer = static_cast<Qt3DRender::QBuffer *>(positionAttr->buffer());
 
-        // Load the geometry
-        QT_WARNING_PUSH
-        QT_WARNING_DISABLE_DEPRECATED
-        const QByteArray data = (*vertexBuffer->dataGenerator())();
-        vertexBuffer->setData(data);
-        QT_WARNING_POP
-
         transform->setTranslation(position);
 
         addComponent(picker);
diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp
index cbb141d2e..0f0a101d3 100644
--- a/tests/auto/render/qbuffer/tst_qbuffer.cpp
+++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp
@@ -36,36 +36,9 @@ QT_WARNING_DISABLE_DEPRECATED
 
 #include <Qt3DRender/qbuffer.h>
 #include <Qt3DRender/private/qbuffer_p.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
 
 #include "testarbiter.h"
 
-class TestFunctor : public Qt3DRender::QBufferDataGenerator
-{
-public:
-    explicit TestFunctor(int size)
-        : m_size(size)
-    {}
-
-    QByteArray operator ()() final
-    {
-        return QByteArray();
-    }
-
-    bool operator ==(const Qt3DRender::QBufferDataGenerator &other) const final
-    {
-        const TestFunctor *otherFunctor = Qt3DRender::functor_cast<TestFunctor>(&other);
-        if (otherFunctor != nullptr)
-            return otherFunctor->m_size == m_size;
-        return false;
-    }
-
-    QT3D_FUNCTOR(TestFunctor)
-
-private:
-    int m_size;
-};
-
 class tst_QBuffer: public QObject
 {
     Q_OBJECT
@@ -98,17 +71,6 @@ private Q_SLOTS:
         arbiter.clear();
 
         // WHEN
-        Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355));
-        buffer->setDataGenerator(functor);
-        QCoreApplication::processEvents();
-
-        // THEN
-        QCOMPARE(arbiter.dirtyNodes().size(), 1);
-        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
-
-        arbiter.clear();
-
-        // WHEN
         buffer->setSyncData(true);
 
         // THEN
diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
index fd438ab2f..2908842eb 100644
--- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
+++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
@@ -55,7 +55,6 @@
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
 #include <Qt3DRender/private/expandboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 
@@ -177,14 +176,6 @@ void runRequiredJobs(Qt3DRender::TestAspect *test)
     updateWorldTransform.setManagers(test->nodeManagers());
     updateWorldTransform.run();
 
-    // For each buffer
-    QVector<Qt3DRender::Render::HBuffer> bufferHandles = test->nodeManagers()->bufferManager()->activeHandles();
-    for (auto bufferHandle : bufferHandles) {
-        Qt3DRender::Render::LoadBufferJob loadBuffer(bufferHandle);
-        loadBuffer.setNodeManager(test->nodeManagers());
-        loadBuffer.run();
-    }
-
     Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
     calcBVolume.setManagers(test->nodeManagers());
     calcBVolume.setRoot(test->sceneRoot());