Merge remote-tracking branch 'origin/5.15' into dev

Change-Id: I0a9fdfe15c620b8a0d58137ca22bab5e246aab2a

58 files changed, 1094 insertions, 517 deletions

diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index 80298780a..34d195221 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -204,13 +204,150 @@ class tst_BoundingSphere : public Qt3DCore::QBackendNodeTester
 private:
 
 private Q_SLOTS:
+    void checkIsNull() {
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        QVERIFY(defaultSphere.isNull());
+    }
+
+    void remainsNotNullAfterTransform() {
+        QMatrix4x4 mat;
+        mat.translate(-5,-5,-5);
+        auto mMat = Matrix4x4(mat);
+        auto pointSphere = Qt3DRender::Render::Sphere(Vector3D(5.f,5.f,5.f),0.f);
+        pointSphere.transform(mMat);
+        QVERIFY(!pointSphere.isNull());
+        QVERIFY(pointSphere.center() == Vector3D(0.,0.,0));
+        QVERIFY(pointSphere.radius() == 0.f);
+    }
+
+    void remainsNullAfterTransform() {
+        QMatrix4x4 mat;
+        mat.translate(-5,-5,-5);
+        auto mMat = Matrix4x4(mat);
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        defaultSphere.transform(mMat);
+        QVERIFY(defaultSphere.isNull());
+    }
+
+    void expandToContainSphere() {
+        auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
+        auto secondValidSphere = Qt3DRender::Render::Sphere(Vector3D(10.f,10.f,10.f),1.f);
+        firstValidSphere.expandToContain(secondValidSphere);
+        QVERIFY(firstValidSphere.center()==Vector3D(0.f,0.f,0.f));
+        float dist = static_cast<float>((2 + sqrt(3.*(20)*(20)))/2.);
+        QVERIFY(qFuzzyCompare(firstValidSphere.radius(), dist));
+    }
+
+    void expandToContainSphereOneInvalid() {
+        auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        auto copiedSphere = firstValidSphere;
+        firstValidSphere.expandToContain(defaultSphere);
+        QVERIFY(firstValidSphere.center() == copiedSphere.center());
+        QVERIFY(firstValidSphere.radius() == copiedSphere.radius());
+        QVERIFY(!firstValidSphere.isNull());
+    }
+
+    void expandToContainOtherSphereInvalid() {
+        auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        defaultSphere.expandToContain(firstValidSphere);
+        QVERIFY(defaultSphere.center() == firstValidSphere.center());
+        QVERIFY(defaultSphere.radius() == firstValidSphere.radius());
+        QVERIFY(!defaultSphere.isNull());
+    }
+
+    void expandNullSphereWithNullSphere() {
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        auto otherDefaultSphere = Qt3DRender::Render::Sphere();
+        defaultSphere.expandToContain(otherDefaultSphere);
+        QVERIFY(defaultSphere.isNull());
+    }
+
+    void expandToContainPoint() {
+        auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
+        firstValidSphere.expandToContain(Vector3D(0,0,0));
+        QVERIFY(!firstValidSphere.isNull());
+        float expectedRadius = static_cast<float>((1 + qSqrt(3.*(10)*(10)))/2.);
+        QVERIFY(qFuzzyCompare(firstValidSphere.radius(), expectedRadius));
+    }
+
+    void nullSphereExpandToContainPoint() {
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        defaultSphere.expandToContain(Vector3D(5,5,5));
+        QVERIFY(!defaultSphere.isNull());
+        QVERIFY(defaultSphere.center() == Vector3D(5,5,5));
+        QVERIFY(qFuzzyIsNull(defaultSphere.radius()));
+    }
+
+    void nullSphereExpandToOrigin() {
+        auto defaultSphere = Qt3DRender::Render::Sphere();
+        defaultSphere.expandToContain(Vector3D(0,0,0));
+        QVERIFY(!defaultSphere.isNull());
+        QVERIFY(defaultSphere.center() == Vector3D(0,0,0));
+        QVERIFY(qFuzzyIsNull(defaultSphere.radius()));
+    }
+
+    void ritterSphereCubePoints() {
+        QVector<Vector3D> cubePts={
+            Vector3D(-0.5, -0.5,  0.5),
+            Vector3D( 0.5, -0.5, -0.5),
+            Vector3D(-0.5,  0.5, -0.5),
+            Vector3D( 0.5,  0.5, -0.5),
+            Vector3D(-0.5, -0.5, -0.5),
+            Vector3D( 0.5, -0.5,  0.5),
+            Vector3D(-0.5,  0.5,  0.5),
+            Vector3D( 0.5,  0.5,  0.5)
+        };
+        auto ritterSphere=Qt3DRender::Render::Sphere::fromPoints(cubePts);
+        QVERIFY(!ritterSphere.isNull());
+        QVERIFY(qFuzzyIsNull(ritterSphere.center().x()));
+        QVERIFY(qFuzzyIsNull(ritterSphere.center().y()));
+        QVERIFY(qFuzzyIsNull(ritterSphere.center().z()));
+        QVERIFY(qFuzzyCompare(ritterSphere.radius(), static_cast<float>(qSqrt(3)/2)));
+    }
+
+    void ritterSphereRandomPoints() {
+        QVector<Vector3D> randomPts={
+            Vector3D(-81, 55, 46),
+            Vector3D(-91, -73, -42),
+            Vector3D(-50, -76, -77),
+            Vector3D(-40, 63, 58),
+            Vector3D(-28, -2, -57),
+            Vector3D(84, 17, 33),
+            Vector3D(53, 11, -49),
+            Vector3D(-7, -24, -86),
+            Vector3D(-89, 6, 76),
+            Vector3D(46, -18, -27)
+        };
+
+        auto ritterSphere = Qt3DRender::Render::Sphere::fromPoints(randomPts);
+        QVERIFY(!ritterSphere.isNull());
+        QVERIFY(qFuzzyCompare(ritterSphere.center().x(), 17.f));
+        QVERIFY(qFuzzyCompare(ritterSphere.center().y(), -29.5f));
+        QVERIFY(qFuzzyCompare(ritterSphere.center().z(), -22.0f));
+        QVERIFY(qFuzzyCompare(ritterSphere.radius(), 148.66152831179963f));
+    }
+
+    void ritterSphereOnePoint() {
+        QVector<Vector3D> singlePt={
+            Vector3D(-0.5, -0.5, -0.5),
+        };
+        auto ritterSphere = Qt3DRender::Render::Sphere::fromPoints(singlePt);
+        QVERIFY(!ritterSphere.isNull());
+        QVERIFY(qFuzzyCompare(ritterSphere.center().x(), -0.5f));
+        QVERIFY(qFuzzyCompare(ritterSphere.center().y(), -0.5f));
+        QVERIFY(qFuzzyCompare(ritterSphere.center().z(), -0.5f));
+        QVERIFY(qFuzzyIsNull(ritterSphere.radius()));
+    }
+
     void checkExtraGeometries_data()
     {
         QTest::addColumn<QString>("qmlFile");
         QTest::addColumn<QVector3D>("sphereCenter");
         QTest::addColumn<float>("sphereRadius");
         QTest::newRow("SphereMesh") << "qrc:/sphere.qml" << QVector3D(0.f, 0.f, 0.f) << 1.f;
-        QTest::newRow("CubeMesh") << "qrc:/cube.qml" << QVector3D(0.0928356f, -0.212021f, -0.0467958f) << 1.07583f; // weird!
+        QTest::newRow("CubeMesh") << "qrc:/cube.qml" << QVector3D(0.f, 0.f, 0.f) << static_cast<float>(qSqrt(3.)/2.); // not weird at all
     }
 
     void checkExtraGeometries()
@@ -235,9 +372,10 @@ private Q_SLOTS:
         const auto boundingSphere = test->sceneRoot()->worldBoundingVolumeWithChildren();
         qDebug() << qmlFile << boundingSphere->radius() << boundingSphere->center();
         QCOMPARE(boundingSphere->radius(), sphereRadius);
-        QVERIFY(qAbs(boundingSphere->center().x() - sphereCenter.x()) < 0.000001f);     // qFuzzyCompare hates 0s
-        QVERIFY(qAbs(boundingSphere->center().y() - sphereCenter.y()) < 0.000001f);
-        QVERIFY(qAbs(boundingSphere->center().z() - sphereCenter.z()) < 0.000001f);
+
+        QVERIFY(qFuzzyIsNull(boundingSphere->center().x() - sphereCenter.x()));
+        QVERIFY(qFuzzyIsNull(boundingSphere->center().y() - sphereCenter.y()));
+        QVERIFY(qFuzzyIsNull(boundingSphere->center().z() - sphereCenter.z()));
     }
 
     void checkCustomGeometry_data()
@@ -247,10 +385,10 @@ private Q_SLOTS:
         QTest::addColumn<QVector3D>("expectedCenter");
         QTest::addColumn<float>("expectedRadius");
         QTest::addColumn<bool>("withPrimitiveRestart");
-        QTest::newRow("all") << 0 << 0 << QVector3D(-0.488892f, 0.0192147f, -75.4804f) << 25.5442f << false;
+        QTest::newRow("all") << 0 << 0 << QVector3D(0.0f, 0.0f, -75.0f) << 25.03997f << false;
         QTest::newRow("first only") << 3 << 0 << QVector3D(0, 1, -100) << 1.0f << false;
         QTest::newRow("second only") << 3 << int(3 * sizeof(ushort)) << QVector3D(0, -1, -50) << 1.0f << false;
-        QTest::newRow("all with primitive restart") << 0 << 0 << QVector3D(-0.488892f, 0.0192147f, -75.4804f) << 25.5442f << true;
+        QTest::newRow("all with primitive restart") << 0 << 0 << QVector3D(0.0f, 0.0f, -75.0f) << 25.03997f << true;
         QTest::newRow("first only with primitive restart") << 4 << 0 << QVector3D(0, 1, -100) << 1.0f << true;
         QTest::newRow("second only with primitive restart") << 4 << int(3 * sizeof(ushort)) << QVector3D(0, -1, -50) << 1.0f << true;
     }
@@ -376,18 +514,17 @@ private Q_SLOTS:
         float radius = entityBackend->localBoundingVolume()->radius();
         qDebug() << radius << center;
 
-        // truncate and compare integers only
-        QCOMPARE(int(radius), int(expectedRadius));
-        QCOMPARE(int(center.x()), int(expectedCenter.x()));
-        QCOMPARE(int(center.y()), int(expectedCenter.y()));
-        QCOMPARE(int(center.z()), int(expectedCenter.z()));
+        QCOMPARE(radius, expectedRadius);
+        QCOMPARE(center.x(), expectedCenter.x());
+        QCOMPARE(center.y(), expectedCenter.y());
+        QCOMPARE(center.z(), expectedCenter.z());
     }
 
     void checkCustomPackedGeometry()
     {
         int drawVertexCount = 6;
-        QVector3D expectedCenter(-0.488892f, 0.0192147f, -75.4804f);
-        float expectedRadius = 25.5442f;
+        QVector3D expectedCenter(0.0f, 0.0f, -75.0f);
+        float expectedRadius = 25.03997f;
 
         // two triangles with different Z
         QByteArray vdata;
@@ -467,11 +604,10 @@ private Q_SLOTS:
         float radius = entityBackend->localBoundingVolume()->radius();
         qDebug() << radius << center;
 
-        // truncate and compare integers only
-        QVERIFY(int(radius) == int(expectedRadius));
-        QVERIFY(int(center.x()) == int(expectedCenter.x()));
-        QVERIFY(int(center.y()) == int(expectedCenter.y()));
-        QVERIFY(int(center.z()) == int(expectedCenter.z()));
+        QCOMPARE(radius, expectedRadius);
+        QCOMPARE(center.x(), expectedCenter.x());
+        QCOMPARE(center.y(), expectedCenter.y());
+        QCOMPARE(center.z(), expectedCenter.z());
     }
 };
 
diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp
index 1487d3728..48215bea5 100644
--- a/tests/auto/render/buffer/tst_buffer.cpp
+++ b/tests/auto/render/buffer/tst_buffer.cpp
@@ -113,26 +113,40 @@ private Q_SLOTS:
 
         // GIVEN
         Qt3DRender::QBuffer frontendBuffer;
-        frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
-        frontendBuffer.setData(QByteArrayLiteral("C7KR4"));
-        frontendBuffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73)));
 
         // WHEN
         backendBuffer.setManager(&bufferManager);
         backendBuffer.setRenderer(&renderer);
         simulateInitializationSync(&frontendBuffer, &backendBuffer);
 
-        frontendBuffer.updateData(2, QByteArrayLiteral("LS5"));
+        // THEN
+        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("C7LS5"));
+        QCOMPARE(backendBuffer.data(), QByteArrayLiteral("C7KR4"));
         QVERIFY(!backendBuffer.dataGenerator().isNull());
         QVERIFY(!backendBuffer.pendingBufferUpdates().empty());
 
         // WHEN
+        frontendBuffer.updateData(2, QByteArrayLiteral("LS5"));
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
+
+        // THEN
+        QCOMPARE(backendBuffer.isDirty(), true);
+        QCOMPARE(backendBuffer.data(), QByteArrayLiteral("C7LS5"));
+        // WHEN
         backendBuffer.cleanup();
 
         // THEN
diff --git a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
index 770f7e72d..a7cea2ef2 100644
--- a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
+++ b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
@@ -266,6 +266,24 @@ private Q_SLOTS:
         }
     }
 
+    void checCleanupMarksDirty()
+    {
+        // GIVEN
+        TestRenderer renderer;
+        Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode();
+
+        backendFGNode->setRenderer(&renderer);
+
+        // THEN
+        QVERIFY(renderer.dirtyBits() == 0);
+
+        // WHEN
+        backendFGNode->cleanup();
+
+        // THEN
+        QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
+    }
+
 };
 
 QTEST_MAIN(tst_FrameGraphNode)
diff --git a/tests/auto/render/ktxtextures/data/16_16.png b/tests/auto/render/ktxtextures/data/16_16.png
new file mode 100644
index 000000000..aefb48dc4
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16.png
diff --git a/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_7.KTX b/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_7.KTX
new file mode 100644
index 000000000..953f300ad
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_7.KTX
diff --git a/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_8.KTX b/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_8.KTX
new file mode 100644
index 000000000..4c23241e4
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16_PNG_ASTC_8.KTX
diff --git a/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGBA_11.KTX b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGBA_11.KTX
new file mode 100644
index 000000000..01646e99a
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGBA_11.KTX
diff --git a/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGB_13.KTX b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGB_13.KTX
new file mode 100644
index 000000000..2d2efff1b
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC2_RGB_13.KTX
diff --git a/tests/auto/render/ktxtextures/data/16_16_PNG_ETC_RGB_12.KTX b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC_RGB_12.KTX
new file mode 100644
index 000000000..15e30abc8
--- /dev/null
+++ b/tests/auto/render/ktxtextures/data/16_16_PNG_ETC_RGB_12.KTX
diff --git a/tests/auto/render/ktxtextures/ktxtextures.pro b/tests/auto/render/ktxtextures/ktxtextures.pro
new file mode 100644
index 000000000..beca06dc2
--- /dev/null
+++ b/tests/auto/render/ktxtextures/ktxtextures.pro
@@ -0,0 +1,11 @@
+TEMPLATE = app
+
+TARGET = tst_ktxtextures
+
+CONFIG += testcase
+
+SOURCES += tst_ktxtextures.cpp
+
+TESTDATA = data/*
+
+QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib
diff --git a/tests/auto/render/ktxtextures/tst_ktxtextures.cpp b/tests/auto/render/ktxtextures/tst_ktxtextures.cpp
new file mode 100644
index 000000000..57ccd3652
--- /dev/null
+++ b/tests/auto/render/ktxtextures/tst_ktxtextures.cpp
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 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:GPL-EXCEPT$
+** 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 General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** 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-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QTest>
+#include <Qt3DRender/qtextureimagedata.h>
+#include <Qt3DRender/private/qtexture_p.h>
+
+class tst_KtxTextures : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void ktxImageData();
+};
+
+void tst_KtxTextures::ktxImageData()
+{
+    const struct TextureInfo {
+        const char *source;
+        int width;
+        int height;
+        int depth;
+        int faces;
+        int mipmapLevels;
+        QOpenGLTexture::TextureFormat format;
+    } textures[] = {
+        { "data/16_16_PNG_ASTC_7.KTX", 16, 16, 1, 1, 1, QOpenGLTexture::RGBA_ASTC_4x4 },
+        { "data/16_16_PNG_ASTC_8.KTX", 16, 16, 1, 1, 1, QOpenGLTexture::RGBA_ASTC_4x4 },
+        { "data/16_16_PNG_ETC2_RGB_13.KTX", 16, 16, 1, 1, 1, QOpenGLTexture::RGB8_ETC2 },
+        { "data/16_16_PNG_ETC2_RGBA_11.KTX", 16, 16, 1, 1, 1, QOpenGLTexture::RGBA8_ETC2_EAC },
+        { "data/16_16_PNG_ETC_RGB_12.KTX", 16, 16, 1, 1, 1, QOpenGLTexture::RGB8_ETC1 },
+    };
+
+    for (unsigned i = 0; i < sizeof(textures)/sizeof(*textures); i++) {
+        const TextureInfo *texture = &textures[i];
+
+        Qt3DRender::QTextureImageDataPtr data = Qt3DRender::TextureLoadingHelper::loadTextureData(QUrl::fromLocalFile(QFINDTESTDATA(texture->source)), true, false);
+
+        QVERIFY(data);
+        QCOMPARE(data->width(), texture->width);
+        QCOMPARE(data->height(), texture->height);
+        QCOMPARE(data->faces(), texture->faces);
+        QCOMPARE(data->mipLevels(), texture->mipmapLevels);
+        QCOMPARE(data->format(), texture->format);
+    }
+}
+
+QTEST_APPLESS_MAIN(tst_KtxTextures)
+
+#include "tst_ktxtextures.moc"
diff --git a/tests/auto/render/objectpicker/tst_objectpicker.cpp b/tests/auto/render/objectpicker/tst_objectpicker.cpp
index a8d9bd010..5fc988d47 100644
--- a/tests/auto/render/objectpicker/tst_objectpicker.cpp
+++ b/tests/auto/render/objectpicker/tst_objectpicker.cpp
@@ -137,65 +137,6 @@ private Q_SLOTS:
             QVERIFY(renderer.dirtyBits() != 0);
         }
     }
-
-    void checkBackendPropertyNotifications()
-    {
-        // GIVEN
-        TestArbiter arbiter;
-        Qt3DRender::Render::ObjectPicker objectPicker;
-        Qt3DCore::QBackendNodePrivate::get(&objectPicker)->setArbiter(&arbiter);
-        Qt3DRender::QPickEventPtr event(new Qt3DRender::QPickEvent);
-
-        // WHEN
-        objectPicker.onPressed(event, Qt3DCore::QNodeId());
-
-        // THEN
-        QCOMPARE(arbiter.events.count(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-
-        arbiter.events.clear();
-
-        // WHEN
-        objectPicker.onReleased(event, Qt3DCore::QNodeId());
-
-        // THEN
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-
-        arbiter.events.clear();
-
-        // WHEN
-        objectPicker.onClicked(event, Qt3DCore::QNodeId());
-
-        // THEN
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "clicked");
-
-        arbiter.events.clear();
-
-        // WHEN
-        objectPicker.onEntered();
-
-        // THEN
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "entered");
-
-        arbiter.events.clear();
-
-        // WHEN
-        objectPicker.onExited();
-
-        // THEN
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "exited");
-
-        arbiter.events.clear();
-    }
 };
 
 
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index 1fbdc4d04..5191b1a36 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -34,6 +34,10 @@
 #include <Qt3DCore/qtransform.h>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
+#include <Qt3DCore/private/qaspectmanager_p.h>
+#include <Qt3DCore/private/qscene_p.h>
+#include <Qt3DCore/private/qaspectengine_p.h>
+#include <Qt3DCore/private/qaspectjob_p.h>
 #include <QtQuick/qquickwindow.h>
 
 #include <Qt3DRender/QCamera>
@@ -60,6 +64,8 @@
 #include <Qt3DRender/private/qobjectpicker_p.h>
 #include <Qt3DRender/private/nopicking_p.h>
 
+#include <QSignalSpy>
+
 #include <private/qpickevent_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -114,10 +120,18 @@ public:
         : Qt3DRender::QRenderAspect(Qt3DRender::QRenderAspect::Synchronous)
         , m_sceneRoot(nullptr)
     {
-        QRenderAspect::onRegistered();
-
+        m_engine = new Qt3DCore::QAspectEngine(this);
+        m_engine->registerAspect(this);
+        Q_ASSERT(d_func()->m_aspectManager);
+
+        // do what QAspectEngine::setRootEntity does since we don't want to enter the simulation loop
+        Qt3DCore::QEntityPtr proot(qobject_cast<Qt3DCore::QEntity *>(root), [](Qt3DCore::QEntity *) { });
+        Qt3DCore::QAspectEnginePrivate *aed = Qt3DCore::QAspectEnginePrivate::get(m_engine);
+        aed->m_root = proot;
+        aed->initialize();
+        aed->initNodeTree(root);
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
+        aed->m_aspectManager->setRootEntity(proot.data(), nodes);
 
         Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -126,7 +140,17 @@ public:
 
     ~TestAspect()
     {
-        QRenderAspect::onUnregistered();
+        using namespace Qt3DCore;
+        QNodeVisitor visitor;
+        visitor.traverse(m_engine->rootEntity().data(), [](QNode *node) {
+            QNodePrivate *d = QNodePrivate::get(node);
+            d->m_scene = nullptr;
+            d->m_changeArbiter = nullptr;
+        });
+
+        m_engine->unregisterAspect(this);
+        delete m_engine;
+        m_engine = nullptr;
     }
 
     void onRegistered() { QRenderAspect::onRegistered(); }
@@ -136,8 +160,10 @@ public:
     Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const { return d_func()->m_renderer->frameGraphRoot(); }
     Qt3DRender::Render::RenderSettings *renderSettings() const { return d_func()->m_renderer->settings(); }
     Qt3DRender::Render::Entity *sceneRoot() const { return m_sceneRoot; }
-
+    Qt3DCore::QAspectManager *aspectManager() const { return  d_func()->m_aspectManager; }
+    Qt3DCore::QChangeArbiter *arbiter() const { return d_func()->m_arbiter; }
 private:
+    Qt3DCore::QAspectEngine *m_engine;
     Render::Entity *m_sceneRoot;
 };
 
@@ -285,7 +311,7 @@ private Q_SLOTS:
         auto vca = results.first();
         QCOMPARE(vca.area, QSize(600, 600));
         QCOMPARE(vca.cameraId, camera->id());
-        QCOMPARE(vca.viewport, QRectF(0.0f, 0.0f, 1.0f, 1.0f));
+        QCOMPARE(vca.viewport, QRectF(0., 0., 1., 1.));
     }
 
     void checkCurrentPickerChange_data()
@@ -344,7 +370,7 @@ private Q_SLOTS:
 
         // WHEN
         QList<QPair<QObject *,QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -357,7 +383,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -367,7 +393,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -380,7 +406,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -440,7 +466,7 @@ private Q_SLOTS:
 
         // WHEN
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 440.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400., 440.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
@@ -490,7 +516,7 @@ private Q_SLOTS:
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
 
@@ -547,7 +573,7 @@ private Q_SLOTS:
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
@@ -597,7 +623,7 @@ private Q_SLOTS:
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
@@ -608,7 +634,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
@@ -658,7 +684,7 @@ private Q_SLOTS:
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
@@ -669,7 +695,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
@@ -719,7 +745,7 @@ private Q_SLOTS:
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         const bool earlyReturn = !pickBVJob.runHelper();
@@ -740,6 +766,7 @@ private Q_SLOTS:
         QmlSceneReader sceneReader(QUrl("qrc:/testscene_dragenabled.qml"));
         QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root()));
         QVERIFY(root);
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
 
         QList<Qt3DRender::QRenderSettings *> renderSettings = root->findChildren<Qt3DRender::QRenderSettings *>();
         QCOMPARE(renderSettings.size(), 1);
@@ -751,9 +778,7 @@ private Q_SLOTS:
         settings->setPickMethod(pickMethod);
         settings->setPickResultMode(pickResultMode);
         settings->setFaceOrientationPickingMode(faceOrientationPickingMode);
-
-        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
-        TestArbiter arbiter;
+        test->renderSettings()->syncFromFrontEnd(renderSettings.first(), false);
 
         // Runs Required jobs
         runRequiredJobs(test.data());
@@ -770,7 +795,7 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter);
+        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(test->arbiter());
 
         QCOMPARE(test->renderSettings()->pickMethod(), pickMethod);
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
@@ -785,94 +810,88 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
+        QSignalSpy mouseButtonPressedSpy(picker1, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker1, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker1, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker1, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 2 : 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-        Qt3DRender::QObjectPickerEvent pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(!Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
-        if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking)
-            QVERIFY(pickEvent.event.dynamicCast<Qt3DRender::QPickTriangleEvent>());
-
-        arbiter.events.clear();
+        QVERIFY(picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
 
         // WHEN -> Move on same object
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Moved
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 2 : 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "moved");
-        pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(!Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
-        if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking)
-            QVERIFY(pickEvent.event.dynamicCast<Qt3DRender::QPickTriangleEvent>());
-
-        arbiter.events.clear();
+        QVERIFY(picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
 
         // WHEN -> Release on object
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Released + Clicked
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 2);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-        pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(!Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
-        if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking)
-            QVERIFY(pickEvent.event.dynamicCast<Qt3DRender::QPickTriangleEvent>());
-        change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "clicked");
-        pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(!Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
-        if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking)
-            QVERIFY(pickEvent.event.dynamicCast<Qt3DRender::QPickTriangleEvent>());
-
-        arbiter.events.clear();
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseButtonReleasedSpy.count(), /*backAndFrontPicking ? 2 :*/ 1);
+        QCOMPARE(mouseClickedSpy.count(), 1);
+
+        mouseButtonPressedSpy.clear();
+        mouseMovedSpy.clear();
+        mouseButtonReleasedSpy.clear();
+        mouseClickedSpy.clear();
 
         // WHEN -> Release outside of object
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0, 0.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Released
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 3 : 2);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-        change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-
-        arbiter.events.clear();
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
     }
 
     void checkDispatchReleaseEventOnLastPickerWhenMovingOutOfViewport()
@@ -910,57 +929,70 @@ private Q_SLOTS:
         QVERIFY(backendPicker1);
         Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter);
 
+        QSignalSpy mouseButtonPressedSpy(picker1, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker1, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker1, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker1, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+
+
         // WHEN -> Pressed on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-        Qt3DRender::QObjectPickerEvent pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(!Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
-        QVERIFY(pickEvent.event.dynamicCast<Qt3DRender::QPickTriangleEvent>());
-
-        arbiter.events.clear();
+        QVERIFY(picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
 
         // WHEN -> Releasing out of the viewport
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0f, 10000.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Should have received released event
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-        pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-        QVERIFY(Qt3DRender::QPickEventPrivate::get(pickEvent.event.data())->m_entity.isNull());
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
 
-        arbiter.events.clear();
 
         // WHEN -> Releasing out of the viewport
+        mouseButtonPressedSpy.clear();
+        mouseMovedSpy.clear();
+        mouseButtonReleasedSpy.clear();
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0f, 10000.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Should have received nothing
-        QCOMPARE(arbiter.events.count(), 0);
+        QVERIFY(!backendPicker1->isPressed());
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 0);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
     }
 
     void checkDispatchHoverEvent_data()
@@ -1010,60 +1042,64 @@ private Q_SLOTS:
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
         QCOMPARE(test->renderSettings()->faceOrientationPickingMode(), faceOrientationPickingMode);
 
+        QSignalSpy mouseEntered(picker1, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited(picker1, &Qt3DRender::QObjectPicker::exited);
+
+        QVERIFY(mouseEntered.isValid());
+        QVERIFY(mouseExited.isValid());
+
         // WHEN -> Hover on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Entered
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "entered");
-
-        arbiter.events.clear();
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseEntered.count(), 1);
+        QCOMPARE(mouseExited.count(), 0);
 
         // WHEN -> HoverMove Out
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(20.0f, 40.0f),
+        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(20.0, 40.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN - Exited
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "exited");
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseEntered.count(), 1);
+        QCOMPARE(mouseExited.count(), 1);
 
-        arbiter.events.clear();
+        mouseEntered.clear();
+        mouseExited.clear();
 
         // WHEN -> HoverMove In + Pressed other
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(207.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(207.0, 303.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
-        events.push_back({nullptr, QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f),
+        events.push_back({nullptr, QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0, 0.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN - Entered, Exited
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker1->isPressed());
-        QCOMPARE(arbiter.events.count(), 2);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "entered");
-        change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "exited");
-
-        arbiter.events.clear();
+        QVERIFY(!picker1->isPressed());
+        QCOMPARE(mouseEntered.count(), 1);
+        QCOMPARE(mouseExited.count(), 1);
     }
 
     void shouldDispatchMouseEventFromChildren_data()
@@ -1115,78 +1151,94 @@ private Q_SLOTS:
                 (pickResultMode == Qt3DRender::QPickingSettings::AllPicks) &&
                 (faceOrientationPickingMode == Qt3DRender::QPickingSettings::FrontAndBackFace);
 
+        QSignalSpy mouseButtonPressedSpy(picker, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+
         // WHEN -> Pressed on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0, 300.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 2 : 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-
-        arbiter.events.clear();
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
 
         // WHEN -> Move on same object
+        mouseButtonPressedSpy.clear();
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0, 300.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Moved
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 2 : 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "moved");
-
-        arbiter.events.clear();
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 0);
+        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
 
         // WHEN -> Release on object
+        mouseMovedSpy.clear();
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0, 300.0),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Released + Clicked
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), 2);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-        change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "clicked");
-
-        arbiter.events.clear();
+        QVERIFY(!picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 0);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+        QCOMPARE(mouseClickedSpy.count(), 1);
 
         // WHEN -> Release outside of object
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+        mouseButtonPressedSpy.clear();
+        mouseMovedSpy.clear();
+        mouseButtonReleasedSpy.clear();
+
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400., 300.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0., 0.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Released
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), backAndFrontPicking ? 3 : 2);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-        change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "released");
-
-        arbiter.events.clear();
+        QVERIFY(!picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+        QCOMPARE(mouseClickedSpy.count(), 1);
     }
 
     void checkPickerGrabbing_data()
@@ -1212,6 +1264,11 @@ private Q_SLOTS:
         settings->setPickResultMode(pickResultMode);
         settings->setFaceOrientationPickingMode(faceOrientationPickingMode);
 
+        const bool backAndFrontPicking =
+                (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking) &&
+                (pickResultMode == Qt3DRender::QPickingSettings::AllPicks) &&
+                (faceOrientationPickingMode == Qt3DRender::QPickingSettings::FrontAndBackFace);
+
         QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
         TestArbiter arbiter1;
         TestArbiter arbiter2;
@@ -1245,47 +1302,85 @@ private Q_SLOTS:
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
         QCOMPARE(test->renderSettings()->faceOrientationPickingMode(), faceOrientationPickingMode);
 
+        QSignalSpy mouseEntered1(picker1, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited1(picker1, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy1(picker1, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy1(picker1, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy1(picker1, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy1(picker1, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy1.isValid());
+        QVERIFY(mouseMovedSpy1.isValid());
+        QVERIFY(mouseButtonReleasedSpy1.isValid());
+        QVERIFY(mouseClickedSpy1.isValid());
+        QVERIFY(mouseEntered1.isValid());
+        QVERIFY(mouseExited1.isValid());
+
+        QSignalSpy mouseEntered2(picker2, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited2(picker2, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy2(picker2, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy2(picker2, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy2(picker2, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy2(picker2, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy2.isValid());
+        QVERIFY(mouseMovedSpy2.isValid());
+        QVERIFY(mouseButtonReleasedSpy2.isValid());
+        QVERIFY(mouseClickedSpy2.isValid());
+        QVERIFY(mouseEntered2.isValid());
+        QVERIFY(mouseExited2.isValid());
+
         // WHEN -> Pressed on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker1->isPressed());
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter1.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
+        QVERIFY(picker1->isPressed());
 
-        arbiter1.events.clear();
+        QCOMPARE(mouseButtonPressedSpy1.count(), backAndFrontPicking ? 2 : 1);
+        QCOMPARE(mouseMovedSpy1.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+        QCOMPARE(mouseClickedSpy1.count(), 0);
+        QCOMPARE(mouseEntered1.count(), 0);
+        QCOMPARE(mouseExited1.count(), 0);
 
         // WHEN -> Move on next object, show stay on previous picker unless all picks are requested
         events.clear();
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(280.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(280., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Moved over the second picker, is the first one still pressed
         QVERIFY(!earlyReturn);
         if (pickResultMode != Qt3DRender::QPickingSettings::AllPicks) {
             QVERIFY(backendPicker1->isPressed());
-            change = arbiter1.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "moved");
+            QVERIFY(picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+            QCOMPARE(mouseMovedSpy1.count(), 1);
+            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+            QCOMPARE(mouseClickedSpy1.count(), 0);
+            QCOMPARE(mouseEntered1.count(), 0);
+            QCOMPARE(mouseExited1.count(), 0);
         } else {
-            QVERIFY(arbiter2.events.size() > 1);
-            change = arbiter2.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "moved");
-            change = arbiter2.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "entered");
+            QVERIFY(!picker2->isPressed());
+            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+            QCOMPARE(mouseMovedSpy2.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+            QCOMPARE(mouseClickedSpy2.count(), 0);
+            QCOMPARE(mouseEntered2.count(), 1);
+            QCOMPARE(mouseExited2.count(), 0);
         }
-
-        arbiter1.events.clear();
-        arbiter2.events.clear();
     }
 
     void checkParentNoPickerChildPicker()
@@ -1321,22 +1416,41 @@ private Q_SLOTS:
         QVERIFY(backendPicker);
         Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
+        QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy(picker, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+        QVERIFY(mouseEntered.isValid());
+        QVERIFY(mouseExited.isValid());
+
         // WHEN -> Pressed on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400., 300.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
+        QCOMPARE(mouseEntered.count(), 0);
+        QCOMPARE(mouseExited.count(), 0);
     }
 
     void checkPickerAndViewports()
@@ -1372,38 +1486,63 @@ private Q_SLOTS:
         QVERIFY(backendPicker);
         Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
+        QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy(picker, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+        QVERIFY(mouseEntered.isValid());
+        QVERIFY(mouseExited.isValid());
+
         // WHEN -> Pressed on object in vp1
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(280.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(280., 300.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
+        QCOMPARE(mouseEntered.count(), 0);
+        QCOMPARE(mouseExited.count(), 0);
 
         // WHEN reset -> Presset on object in vp2
         backendPicker->cleanup();
         backendPicker->setEnabled(true);
         events.clear();
-        arbiter.events.clear();
 
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320.0f, 300.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 300.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Nothing happened
         QVERIFY(!earlyReturn);
         QVERIFY(!backendPicker->isPressed());
-        QCOMPARE(arbiter.events.count(), 0);
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
+        QCOMPARE(mouseEntered.count(), 0);
+        QCOMPARE(mouseExited.count(), 0);
     }
 
     void checkMultipleRayDirections_data()
@@ -1420,8 +1559,8 @@ private Q_SLOTS:
                 const double angle = M_PI * 2. / (double)n * i;
                 const double x = std::sin(angle) * 10.;
                 const double z = std::cos(angle) * 10.;
-                QVector3D pos(x, 0, z);
-                QVector3D up(0, 1, 0);
+                QVector3D pos(x, 0.f, z);
+                QVector3D up(0.f, 1.f, 0.f);
                 QTest::newRow(QString::number(k++).toLatin1().data()) << m * pos << m * up;
             }
         }
@@ -1466,25 +1605,41 @@ private Q_SLOTS:
         QVERIFY(backendPicker);
         Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
+        QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy(picker, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy(picker, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy(picker, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy(picker, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy.isValid());
+        QVERIFY(mouseMovedSpy.isValid());
+        QVERIFY(mouseButtonReleasedSpy.isValid());
+        QVERIFY(mouseClickedSpy.isValid());
+        QVERIFY(mouseEntered.isValid());
+        QVERIFY(mouseExited.isValid());
+
         // WHEN -> Pressed on object
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
         QList<QPair<QObject *, QMouseEvent>> events;
-        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(303.0f, 303.0f),
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(303., 303.),
                                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
+        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
         // THEN -> Pressed
         QVERIFY(!earlyReturn);
         QVERIFY(backendPicker->isPressed());
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "pressed");
-        Qt3DRender::QObjectPickerEvent pickEvent = change->value().value<Qt3DRender::QObjectPickerEvent>();
-        QVERIFY(pickEvent.event);
-
-        arbiter.events.clear();
+        QVERIFY(picker->isPressed());
+        QCOMPARE(mouseButtonPressedSpy.count(), 1);
+        QCOMPARE(mouseMovedSpy.count(), 0);
+        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        QCOMPARE(mouseClickedSpy.count(), 0);
+        QCOMPARE(mouseEntered.count(), 0);
+        QCOMPARE(mouseExited.count(), 0);
     }
 
     void checkPriorityPicking()
@@ -1523,6 +1678,33 @@ private Q_SLOTS:
         QVERIFY(backendPicker2);
         Qt3DCore::QBackendNodePrivate::get(backendPicker2)->setArbiter(&arbiter2);
 
+        QSignalSpy mouseEntered1(picker1, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited1(picker1, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy1(picker1, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy1(picker1, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy1(picker1, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy1(picker1, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy1.isValid());
+        QVERIFY(mouseMovedSpy1.isValid());
+        QVERIFY(mouseButtonReleasedSpy1.isValid());
+        QVERIFY(mouseClickedSpy1.isValid());
+        QVERIFY(mouseEntered1.isValid());
+        QVERIFY(mouseExited1.isValid());
+
+        QSignalSpy mouseEntered2(picker2, &Qt3DRender::QObjectPicker::entered);
+        QSignalSpy mouseExited2(picker2, &Qt3DRender::QObjectPicker::exited);
+        QSignalSpy mouseButtonPressedSpy2(picker2, &Qt3DRender::QObjectPicker::pressed);
+        QSignalSpy mouseMovedSpy2(picker2, &Qt3DRender::QObjectPicker::moved);
+        QSignalSpy mouseButtonReleasedSpy2(picker2, &Qt3DRender::QObjectPicker::released);
+        QSignalSpy mouseClickedSpy2(picker2, &Qt3DRender::QObjectPicker::clicked);
+
+        QVERIFY(mouseButtonPressedSpy2.isValid());
+        QVERIFY(mouseMovedSpy2.isValid());
+        QVERIFY(mouseButtonReleasedSpy2.isValid());
+        QVERIFY(mouseClickedSpy2.isValid());
+        QVERIFY(mouseEntered2.isValid());
+        QVERIFY(mouseExited2.isValid());
 
         // WHEN both have priority == 0, select closest
         {
@@ -1531,31 +1713,62 @@ private Q_SLOTS:
 
             // WHEN -> Pressed on object
             QList<QPair<QObject *, QMouseEvent>> events;
-            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300.0f, 300.0f),
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
                                                    Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
             pickBVJob.setMouseEvents(events);
             bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
             // THEN -> Select picker with highest priority
             QVERIFY(!earlyReturn);
             QVERIFY(backendPicker1->isPressed());
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter1.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "pressed");
+            QVERIFY(picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+            QCOMPARE(mouseMovedSpy1.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+            QCOMPARE(mouseClickedSpy1.count(), 0);
+            QCOMPARE(mouseEntered1.count(), 0);
+            QCOMPARE(mouseExited1.count(), 0);
 
             QVERIFY(!backendPicker2->isPressed());
-            QVERIFY(arbiter2.events.isEmpty());
-
-            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300.0f, 300.0f),
+            QVERIFY(!picker2->isPressed());
+            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+            QCOMPARE(mouseMovedSpy2.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+            QCOMPARE(mouseClickedSpy2.count(), 0);
+            QCOMPARE(mouseEntered2.count(), 0);
+            QCOMPARE(mouseExited2.count(), 0);
+
+            events.clear();
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
                                                    Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
             pickBVJob.setMouseEvents(events);
             pickBVJob.runHelper();
-            arbiter1.events.clear();
-            arbiter2.events.clear();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
             QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+            QCOMPARE(mouseMovedSpy1.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy1.count(), 1);
+            QCOMPARE(mouseClickedSpy1.count(), 1);
+            QCOMPARE(mouseEntered1.count(), 0);
+            QCOMPARE(mouseExited1.count(), 0);
+
             QVERIFY(!backendPicker2->isPressed());
+            QVERIFY(!picker2->isPressed());
+            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+            QCOMPARE(mouseMovedSpy2.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+            QCOMPARE(mouseClickedSpy2.count(), 0);
+            QCOMPARE(mouseEntered2.count(), 0);
+            QCOMPARE(mouseExited2.count(), 0);
         }
 
+        mouseButtonPressedSpy1.clear();
+        mouseButtonReleasedSpy1.clear();
+        mouseClickedSpy1.clear();
+
         // WHEN furthest one has higher priority, select furthest one
         {
             backendPicker2->setPriority(1000);
@@ -1566,29 +1779,56 @@ private Q_SLOTS:
 
             // WHEN -> Pressed on object
             QList<QPair<QObject *, QMouseEvent>> events;
-            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300.0f, 300.0f),
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
                                                    Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
             pickBVJob.setMouseEvents(events);
             bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
             // THEN -> Select picker with highest priority
             QVERIFY(!earlyReturn);
-            QVERIFY(backendPicker2->isPressed());
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter2.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "pressed");
-
             QVERIFY(!backendPicker1->isPressed());
-            QVERIFY(arbiter1.events.isEmpty());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy1.count(), 0);
+            QCOMPARE(mouseMovedSpy1.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+            QCOMPARE(mouseClickedSpy1.count(), 0);
+            QCOMPARE(mouseEntered1.count(), 0);
+            QCOMPARE(mouseExited1.count(), 0);
 
-            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300.0f, 300.0f),
+            QVERIFY(backendPicker2->isPressed());
+            QVERIFY(picker2->isPressed());
+            QCOMPARE(mouseButtonPressedSpy2.count(), 1);
+            QCOMPARE(mouseMovedSpy2.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+            QCOMPARE(mouseClickedSpy2.count(), 0);
+            QCOMPARE(mouseEntered2.count(), 0);
+            QCOMPARE(mouseExited2.count(), 0);
+
+            events.clear();
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
                                                    Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
             pickBVJob.setMouseEvents(events);
             pickBVJob.runHelper();
-            arbiter1.events.clear();
-            arbiter2.events.clear();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
             QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy1.count(), 0);
+            QCOMPARE(mouseMovedSpy1.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+            QCOMPARE(mouseClickedSpy1.count(), 0);
+            QCOMPARE(mouseEntered1.count(), 0);
+            QCOMPARE(mouseExited1.count(), 0);
+
             QVERIFY(!backendPicker2->isPressed());
+            QVERIFY(!picker2->isPressed());
+            QCOMPARE(mouseButtonPressedSpy2.count(), 1);
+            QCOMPARE(mouseMovedSpy2.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy2.count(), 1);
+            QCOMPARE(mouseClickedSpy2.count(), 1);
+            QCOMPARE(mouseEntered2.count(), 0);
+            QCOMPARE(mouseExited2.count(), 0);
         }
     }
 
@@ -1635,7 +1875,7 @@ private Q_SLOTS:
         auto vca = results.first();
         QCOMPARE(vca.area, QSize(600, 600));
         QCOMPARE(vca.cameraId, camera->id());
-        QCOMPARE(vca.viewport, QRectF(0.0f, 0.0f, 1.0f, 1.0f));
+        QCOMPARE(vca.viewport, QRectF(0., 0., 1., 1.));
     }
 
 };
diff --git a/tests/auto/render/picking/tst_picking.cpp b/tests/auto/render/picking/tst_picking.cpp
index 4f4201e07..d0e6512d5 100644
--- a/tests/auto/render/picking/tst_picking.cpp
+++ b/tests/auto/render/picking/tst_picking.cpp
@@ -153,14 +153,13 @@ private Q_SLOTS:
 
         QCoreApplication::processEvents();
 
+        auto dpicker = [](QObjectPicker *node) {
+            return static_cast<QObjectPickerPrivate *>(QObjectPickerPrivate::get(node));
+        };
+
         // WHEN
         Qt3DRender::QPickEventPtr event(new Qt3DRender::QPickEvent());
-        QVariant v;
-        v.setValue<Qt3DRender::QObjectPickerEvent>({event, Qt3DCore::QNodeId()});
-        Qt3DCore::QPropertyUpdatedChangePtr e(new Qt3DCore::QPropertyUpdatedChange(child11.id()));
-        e->setPropertyName("pressed");
-        e->setValue(v);
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->pressedEvent(event.data());
 
         // THEN
         QCOMPARE(root.pressedCalled, 0);
@@ -171,7 +170,7 @@ private Q_SLOTS:
         // WHEN
         child11.pressedCalled = 0;
         child11.acceptsEvents = false;
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->pressedEvent(event.data());
 
         // THEN
         QCOMPARE(root.pressedCalled, 0);
@@ -184,7 +183,7 @@ private Q_SLOTS:
         child1.pressedCalled = 0;
         child11.acceptsEvents = false;
         child11.pressedCalled = 0;
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->pressedEvent(event.data());
 
         // THEN
         QCOMPARE(root.pressedCalled, 1);
@@ -208,16 +207,14 @@ private Q_SLOTS:
 
         QCoreApplication::processEvents();
 
+        auto dpicker = [](QObjectPicker *node) {
+            return static_cast<QObjectPickerPrivate *>(QObjectPickerPrivate::get(node));
+        };
+
         // WHEN
         Qt3DRender::QPickEventPtr event(new Qt3DRender::QPickEvent());
-        QVariant v;
-        v.setValue<Qt3DRender::QObjectPickerEvent>({event, Qt3DCore::QNodeId()});
-        Qt3DCore::QPropertyUpdatedChangePtr e(new Qt3DCore::QPropertyUpdatedChange(child11.id()));
-        e->setPropertyName("pressed");
-        e->setValue(v);
-        child11.picker->sceneChangeEvent(e);
-        e->setPropertyName("released");
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->pressedEvent(event.data());
+        dpicker(child11.picker)->releasedEvent(event.data());
 
         // THEN
         QCOMPARE(root.releasedCalled, 0);
@@ -229,10 +226,8 @@ private Q_SLOTS:
         child11.releasedCalled = 0;
         child11.pressedCalled = 0;
         child11.acceptsEvents = false;
-        e->setPropertyName("pressed");
-        child11.picker->sceneChangeEvent(e);
-        e->setPropertyName("released");
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->pressedEvent(event.data());
+        dpicker(child11.picker)->releasedEvent(event.data());
 
         // THEN
         QCOMPARE(child1.pressedCalled, 1);
@@ -259,14 +254,13 @@ private Q_SLOTS:
 
         QCoreApplication::processEvents();
 
+        auto dpicker = [](QObjectPicker *node) {
+            return static_cast<QObjectPickerPrivate *>(QObjectPickerPrivate::get(node));
+        };
+
         // WHEN
         Qt3DRender::QPickEventPtr event(new Qt3DRender::QPickEvent());
-        QVariant v;
-        v.setValue<Qt3DRender::QObjectPickerEvent>({event, Qt3DCore::QNodeId()});
-        Qt3DCore::QPropertyUpdatedChangePtr e(new Qt3DCore::QPropertyUpdatedChange(child11.id()));
-        e->setPropertyName("clicked");
-        e->setValue(v);
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->clickedEvent(event.data());
 
         // THEN
         QCOMPARE(root.clickedCalled, 0);
@@ -277,7 +271,7 @@ private Q_SLOTS:
         // WHEN
         child11.clickedCalled = 0;
         child11.acceptsEvents = false;
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->clickedEvent(event.data());
 
         // THEN
         QCOMPARE(root.clickedCalled, 0);
@@ -290,7 +284,7 @@ private Q_SLOTS:
         child1.clickedCalled = 0;
         child11.acceptsEvents = false;
         child11.clickedCalled = 0;
-        child11.picker->sceneChangeEvent(e);
+        dpicker(child11.picker)->clickedEvent(event.data());
 
         // THEN
         QCOMPARE(root.clickedCalled, 1);
diff --git a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
index 07adf12b5..1bed9fc44 100644
--- a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
+++ b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
@@ -29,6 +29,10 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qtransform.h>
+#include <Qt3DRender/qgeometry.h>
+#include <Qt3DRender/qgeometryrenderer.h>
+#include <Qt3DRender/qattribute.h>
+#include <Qt3DRender/qbuffer.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/private/entity_p.h>
@@ -43,6 +47,40 @@ namespace {
 Qt3DCore::QEntity *buildEntityAtDistance(float distance, Qt3DCore::QEntity *parent)
 {
     Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(parent);
+
+    // create geometry with a valid bounding volume - a single point is sufficient
+    auto geometry = new Qt3DRender::QGeometry;
+    auto vertexBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer, geometry);
+
+    auto positionAttribute = new Qt3DRender::QAttribute;
+    positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
+    positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
+    positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float);
+    positionAttribute->setVertexSize(3);
+    positionAttribute->setByteStride(3 * sizeof(float));
+    positionAttribute->setBuffer(vertexBuffer);
+
+    QByteArray vertexBufferData;
+    vertexBufferData.resize(static_cast<int>(3 * sizeof(float)));
+
+    auto vertexArray = reinterpret_cast<float*>(vertexBufferData.data());
+
+    int i = 0;
+    vertexArray[i++] = 0.0f;
+    vertexArray[i++] = 0.0f;
+    vertexArray[i++] = 0.0f;
+
+    vertexBuffer->setData(vertexBufferData);
+    positionAttribute->setCount(1);
+
+    geometry->addAttribute(positionAttribute);
+
+    auto geometryRenderer = new Qt3DRender::QGeometryRenderer;
+    geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Points);
+    geometryRenderer->setGeometry(geometry);
+
+    entity->addComponent(geometryRenderer);
+
     Qt3DCore::QTransform *transform = new Qt3DCore::QTransform(parent);
     const QVector3D t = QVector3D(1.0f, 0.0f, 0.0f) * distance;
 
diff --git a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
index 53c0ec939..5977829a6 100644
--- a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
+++ b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
@@ -234,24 +234,6 @@ private Q_SLOTS:
         QTest::newRow("objectPicker_all_true") << objectPicker;
     }
 
-    // TODO: Avoid cloning here
-//    void checkCloning()
-//    {
-//        // GIVEN
-//        QFETCH(Qt3DRender::QObjectPicker *, objectPicker);
-
-//        // WHEN
-//        Qt3DRender::QObjectPicker *clone = static_cast<Qt3DRender::QObjectPicker *>(QNode::clone(objectPicker));
-//        QCoreApplication::processEvents();
-
-//        // THEN
-//        QVERIFY(clone != nullptr);
-//        QCOMPARE(objectPicker->id(), clone->id());
-//        QCOMPARE(objectPicker->isHoverEnabled(), clone->isHoverEnabled());
-//        QCOMPARE(objectPicker->isPressed(), clone->isPressed());
-//        QCOMPARE(objectPicker->containsMouse(), clone->containsMouse());
-//    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -272,68 +254,6 @@ private Q_SLOTS:
 
         arbiter.dirtyNodes.clear();
     }
-
-    void checkBackendUpdates_data()
-    {
-        QTest::addColumn<QByteArray>("signalPrototype");
-        QTest::addColumn<QByteArray>("propertyName");
-        QTest::addColumn<bool>("requiresEvent");
-
-        QTest::newRow("clicked")
-                << QByteArray(SIGNAL(clicked(Qt3DRender::QPickEvent *)))
-                << QByteArrayLiteral("clicked")
-                << true;
-
-        QTest::newRow("pressed")
-                << QByteArray(SIGNAL(pressed(Qt3DRender::QPickEvent *)))
-                << QByteArrayLiteral("pressed")
-                << true;
-
-        QTest::newRow("released")
-                << QByteArray(SIGNAL(released(Qt3DRender::QPickEvent *)))
-                << QByteArrayLiteral("released")
-                << true;
-
-        QTest::newRow("entered")
-                << QByteArray(SIGNAL(entered()))
-                << QByteArrayLiteral("entered")
-                << false;
-
-        QTest::newRow("exited")
-                << QByteArray(SIGNAL(exited()))
-                << QByteArrayLiteral("exited")
-                << false;
-    }
-
-    void checkBackendUpdates()
-    {
-        // GIVEN
-        QFETCH(QByteArray, signalPrototype);
-        QFETCH(QByteArray, propertyName);
-        QFETCH(bool, requiresEvent);
-        Qt3DCore::QScene scene;
-        QScopedPointer<MyObjectPicker> objectPicker(new MyObjectPicker());
-        Qt3DCore::QNodePrivate::get(objectPicker.data())->setScene(&scene);
-
-        QSignalSpy spy(objectPicker.data(), signalPrototype.constData());
-        Qt3DRender::QObjectPickerEvent event {Qt3DRender::QPickEventPtr::create(), Qt3DCore::QNodeId()};
-
-        // WHEN
-        // Create Backend Change and distribute it to frontend node
-        Qt3DCore::QPropertyUpdatedChangePtr e(new Qt3DCore::QPropertyUpdatedChange(objectPicker->id()));
-        e->setPropertyName(propertyName.constData());
-        if (requiresEvent)
-        {
-            QVariant v;
-            v.setValue<Qt3DRender::QObjectPickerEvent>(event);
-            e->setValue(v);
-        }
-        objectPicker->sceneChangeEvent(e);
-
-        // THEN
-        // Check that the QObjectPicker triggers the expected signal
-        QCOMPARE(spy.count(), 1);
-    }
 };
 
 QTEST_MAIN(tst_QObjectPicker)
diff --git a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
index 881c24728..851316e60 100644
--- a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
+++ b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
@@ -594,13 +594,11 @@ private Q_SLOTS:
 
     void checkGeneratedCodePropertyUpdates()
     {
+        Qt3DRender::QShaderProgramBuilderPrivate *dBuilder = static_cast<decltype(dBuilder)>(Qt3DCore::QNodePrivate::get(this));
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(vertexShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::Vertex), QByteArrayLiteral("vertex"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("vertex"), Qt3DRender::QShaderProgram::Vertex);
 
             // THEN
             QVERIFY(spy.isValid());
@@ -610,10 +608,7 @@ private Q_SLOTS:
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(fragmentShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::Fragment), QByteArrayLiteral("fragment"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("fragment"), Qt3DRender::QShaderProgram::Fragment);
 
             // THEN
             QVERIFY(spy.isValid());
@@ -623,10 +618,7 @@ private Q_SLOTS:
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(geometryShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::Geometry), QByteArrayLiteral("geometry"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("geometry"), Qt3DRender::QShaderProgram::Geometry);
 
             // THEN
             QVERIFY(spy.isValid());
@@ -636,10 +628,8 @@ private Q_SLOTS:
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(computeShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::Compute), QByteArrayLiteral("compute"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("compute"), Qt3DRender::QShaderProgram::Compute);
+
 
             // THEN
             QVERIFY(spy.isValid());
@@ -649,10 +639,7 @@ private Q_SLOTS:
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(tessellationControlShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::TessellationControl), QByteArrayLiteral("control"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("control"), Qt3DRender::QShaderProgram::TessellationControl);
 
             // THEN
             QVERIFY(spy.isValid());
@@ -662,10 +649,7 @@ private Q_SLOTS:
         {
             // WHEN
             QSignalSpy spy(this, SIGNAL(tessellationEvaluationShaderCodeChanged(QByteArray)));
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("generatedShaderCode");
-            valueChange->setValue(QVariant::fromValue(QPair<int, QByteArray>(int(Qt3DRender::QShaderProgram::TessellationEvaluation), QByteArrayLiteral("eval"))));
-            sceneChangeEvent(valueChange);
+            dBuilder->setShaderCode(QByteArrayLiteral("eval"), Qt3DRender::QShaderProgram::TessellationEvaluation);
 
             // THEN
             QVERIFY(spy.isValid());
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 786d8050f..180ff7ac1 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -41,6 +41,7 @@ qtConfig(private_tests) {
 #        qboundingvolumedebug \
 #        boundingvolumedebug \
         ddstextures \
+        ktxtextures \
         shadercache \
         layerfiltering \
         filterentitybycomponent \
diff --git a/tests/auto/render/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp
index f620064ed..fcb4c0908 100644
--- a/tests/auto/render/scene2d/tst_scene2d.cpp
+++ b/tests/auto/render/scene2d/tst_scene2d.cpp
@@ -128,7 +128,7 @@ private Q_SLOTS:
             // WHEN
             QScopedPointer<Scene2D> backendScene2d(new Scene2D());
             backendScene2d->setRenderer(&renderer);
-            simulateInitialization(&frontend, backendScene2d.data());
+            simulateInitializationSync(&frontend, backendScene2d.data());
 
             // THEN
             QCOMPARE(backendScene2d->isEnabled(), true);
@@ -144,7 +144,7 @@ private Q_SLOTS:
             QScopedPointer<Scene2D> backendScene2d(new Scene2D());
             frontend.setEnabled(false);
             backendScene2d->setRenderer(&renderer);
-            simulateInitialization(&frontend, backendScene2d.data());
+            simulateInitializationSync(&frontend, backendScene2d.data());
 
             // THEN
             QCOMPARE(backendScene2d->peerId(), frontend.id());
@@ -156,18 +156,18 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::Quick::QScene2D frontend;
         QScopedPointer<Scene2D> backendScene2d(new Scene2D());
         TestRenderer renderer;
         QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput());
         backendScene2d->setRenderer(&renderer);
+        simulateInitializationSync(&frontend, backendScene2d.data());
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendScene2d->sceneChangeEvent(change);
+             frontend.setEnabled(false);
+             backendScene2d->syncFromFrontEnd(&frontend, false);
 
              // THEN
             QCOMPARE(backendScene2d->isEnabled(), newValue);
@@ -175,10 +175,8 @@ private Q_SLOTS:
         {
              // WHEN
              const Qt3DCore::QNodeId newValue = output.data()->id();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("output");
-             change->setValue(QVariant::fromValue(newValue));
-             backendScene2d->sceneChangeEvent(change);
+             frontend.setOutput(output.data());
+             backendScene2d->syncFromFrontEnd(&frontend, false);
 
              // THEN
             QCOMPARE(backendScene2d->m_outputId, newValue);
@@ -186,10 +184,8 @@ private Q_SLOTS:
         {
              // WHEN
              const QScene2D::RenderPolicy newValue = QScene2D::SingleShot;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("renderPolicy");
-             change->setValue(QVariant::fromValue(newValue));
-             backendScene2d->sceneChangeEvent(change);
+             frontend.setRenderPolicy(newValue);
+             backendScene2d->syncFromFrontEnd(&frontend, false);
 
              // THEN
             QCOMPARE(backendScene2d->m_renderPolicy, newValue);
@@ -197,10 +193,7 @@ private Q_SLOTS:
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("mouseEnabled");
-             change->setValue(newValue);
-             backendScene2d->sceneChangeEvent(change);
+             frontend.setMouseEnabled(newValue);
 
              // THEN
             QCOMPARE(backendScene2d->isEnabled(), newValue);
@@ -209,10 +202,11 @@ private Q_SLOTS:
         backendScene2d->cleanup();
     }
 
-
     void testCoordinateCalculation()
     {
         // GIVEN
+        qputenv("QT3D_SCENE2D_DISABLE_RENDERING", "1");
+
         QScopedPointer<TestWindow> testWindow(new TestWindow());
         Scene2DSharedObjectPtr sharedObject(new Scene2DSharedObject(nullptr));
         QScopedPointer<Scene2D> scene2d(new Scene2D());
@@ -336,7 +330,8 @@ private Q_SLOTS:
             QVector3D uvw(1.0, 0.0f, 0.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -350,7 +345,8 @@ private Q_SLOTS:
             QVector3D uvw(0.0, 1.0f, 0.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -364,7 +360,8 @@ private Q_SLOTS:
             QVector3D uvw(0.0, 0.0f, 1.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -378,7 +375,8 @@ private Q_SLOTS:
             QVector3D uvw(1.0, 0.0f, 0.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -392,7 +390,8 @@ private Q_SLOTS:
             QVector3D uvw(0.0, 1.0f, 0.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -406,7 +405,8 @@ private Q_SLOTS:
             QVector3D uvw(0.0, 0.0f, 1.0f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
@@ -420,12 +420,13 @@ private Q_SLOTS:
             QVector3D uvw(0.5f, 0.25f, 0.25f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
             // THEN
-            QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(512.0f, 768.0f)));
+            QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(512.0, 768.0)));
             testWindow->clear();
         }
 
@@ -434,14 +435,17 @@ private Q_SLOTS:
             QVector3D uvw(0.875f, 0.09375f, 0.03125f);
             Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw));
             Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id();
-            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev);
+            Qt3DRender::QPickEventPrivate::get(ev.data())->m_entityPtr = entity.data();
+            scene2d->handlePickEvent(QEvent::MouseButtonPress, ev.data());
 
             QCoreApplication::processEvents();
 
             // THEN
-            QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(96.0f, 896.0f)));
+            QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(96.0, 896.0)));
             testWindow->clear();
         }
+
+        scene2d.reset();
     }
 };
 
diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp
index bfebe2467..d1578aee7 100644
--- a/tests/auto/render/shader/tst_shader.cpp
+++ b/tests/auto/render/shader/tst_shader.cpp
@@ -103,7 +103,7 @@ void tst_RenderShader::matchesFrontendPeer()
 
     for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i)
         QCOMPARE(backend.shaderCode()[i],
-                 frontend->shaderCode( static_cast<const Qt3DRender::QShaderProgram::ShaderType>(i)));
+                 frontend->shaderCode(static_cast<Qt3DRender::QShaderProgram::ShaderType>(i)));
 }
 
 void tst_RenderShader::cleanupLeavesACoherentState()
diff --git a/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp b/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
index 7a9e0fac4..7a08fe018 100644
--- a/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
+++ b/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
@@ -36,7 +36,6 @@
 #include "testrenderer.h"
 #include "testpostmanarbiter.h"
 
-Q_DECLARE_METATYPE(Qt3DRender::Render::ShaderBuilder::ShaderType)
 Q_DECLARE_METATYPE(Qt3DRender::QShaderProgram::ShaderType)
 
 class tst_ShaderBuilder : public Qt3DCore::QBackendNodeTester
@@ -78,8 +77,8 @@ private slots:
         // THEN
         QVERIFY(!shaderBuilder.isEnabled());
         QVERIFY(shaderBuilder.enabledLayers().isEmpty());
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QCOMPARE(shaderBuilder.shaderGraph(type), QUrl());
             QCOMPARE(shaderBuilder.shaderCode(type), QByteArray());
             QVERIFY(!shaderBuilder.isShaderCodeDirty(type));
@@ -158,29 +157,29 @@ private slots:
 
         QCOMPARE(backend.enabledLayers(), frontend->enabledLayers());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::Vertex), frontend->vertexShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::Vertex), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::Vertex), !frontend->vertexShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::Vertex), frontend->vertexShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::Vertex), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::Vertex), !frontend->vertexShaderGraph().isEmpty());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::TessellationControl), frontend->tessellationControlShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::TessellationControl), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::TessellationControl), !frontend->tessellationControlShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::TessellationControl), frontend->tessellationControlShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::TessellationControl), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::TessellationControl), !frontend->tessellationControlShaderGraph().isEmpty());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::TessellationEvaluation), frontend->tessellationEvaluationShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::TessellationEvaluation), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::TessellationEvaluation), !frontend->tessellationEvaluationShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::TessellationEvaluation), frontend->tessellationEvaluationShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::TessellationEvaluation), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::TessellationEvaluation), !frontend->tessellationEvaluationShaderGraph().isEmpty());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::Geometry), frontend->geometryShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::Geometry), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::Geometry), !frontend->geometryShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::Geometry), frontend->geometryShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::Geometry), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::Geometry), !frontend->geometryShaderGraph().isEmpty());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::Fragment), frontend->fragmentShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::Fragment), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::Fragment), !frontend->fragmentShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::Fragment), frontend->fragmentShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::Fragment), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::Fragment), !frontend->fragmentShaderGraph().isEmpty());
 
-        QCOMPARE(backend.shaderGraph(Qt3DRender::Render::ShaderBuilder::Compute), frontend->computeShaderGraph());
-        QCOMPARE(backend.shaderCode(Qt3DRender::Render::ShaderBuilder::Compute), QByteArray());
-        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::Render::ShaderBuilder::Compute), !frontend->computeShaderGraph().isEmpty());
+        QCOMPARE(backend.shaderGraph(Qt3DRender::QShaderProgram::Compute), frontend->computeShaderGraph());
+        QCOMPARE(backend.shaderCode(Qt3DRender::QShaderProgram::Compute), QByteArray());
+        QCOMPARE(backend.isShaderCodeDirty(Qt3DRender::QShaderProgram::Compute), !frontend->computeShaderGraph().isEmpty());
 
         // WHEN
         backend.cleanup();
@@ -188,8 +187,8 @@ private slots:
         // THEN
         QVERIFY(!backend.isEnabled());
         QVERIFY(backend.enabledLayers().isEmpty());
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QCOMPARE(backend.shaderGraph(type), QUrl());
             QCOMPARE(backend.shaderCode(type), QByteArray());
             QVERIFY(!backend.isShaderCodeDirty(type));
@@ -279,16 +278,16 @@ private slots:
         const auto layers = QStringList() << "foo" << "bar";
 
         static const std::pair<
-                Qt3DRender::Render::ShaderBuilder::ShaderType,
+                Qt3DRender::QShaderProgram::ShaderType,
                 void (Qt3DRender::QShaderProgramBuilder::*)(const QUrl &)
                 >
                 shaderTypesToSetters[] = {
-            {Qt3DRender::Render::ShaderBuilder::Vertex, &Qt3DRender::QShaderProgramBuilder::setVertexShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::TessellationControl, &Qt3DRender::QShaderProgramBuilder::setTessellationControlShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::TessellationEvaluation, &Qt3DRender::QShaderProgramBuilder::setTessellationEvaluationShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Geometry, &Qt3DRender::QShaderProgramBuilder::setGeometryShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Fragment, &Qt3DRender::QShaderProgramBuilder::setFragmentShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Compute, &Qt3DRender::QShaderProgramBuilder::setComputeShaderGraph},
+            {Qt3DRender::QShaderProgram::Vertex, &Qt3DRender::QShaderProgramBuilder::setVertexShaderGraph},
+            {Qt3DRender::QShaderProgram::TessellationControl, &Qt3DRender::QShaderProgramBuilder::setTessellationControlShaderGraph},
+            {Qt3DRender::QShaderProgram::TessellationEvaluation, &Qt3DRender::QShaderProgramBuilder::setTessellationEvaluationShaderGraph},
+            {Qt3DRender::QShaderProgram::Geometry, &Qt3DRender::QShaderProgramBuilder::setGeometryShaderGraph},
+            {Qt3DRender::QShaderProgram::Fragment, &Qt3DRender::QShaderProgramBuilder::setFragmentShaderGraph},
+            {Qt3DRender::QShaderProgram::Compute, &Qt3DRender::QShaderProgramBuilder::setComputeShaderGraph},
         };
 
 
@@ -303,8 +302,8 @@ private slots:
 
         // THEN
         QCOMPARE(backend.enabledLayers(), layers);
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QVERIFY(backend.isShaderCodeDirty(type));
             backend.generateCode(type); // Resets the dirty flag
         }
@@ -317,8 +316,8 @@ private slots:
 
         // THEN
         QCOMPARE(backend.enabledLayers(), layers);
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QVERIFY(!backend.isShaderCodeDirty(type));
             backend.generateCode(type); // Resets the dirty flag
         }
@@ -331,8 +330,8 @@ private slots:
 
         // THEN
         QVERIFY(backend.shaderProgramId().isNull());
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QVERIFY(backend.isShaderCodeDirty(type));
             backend.generateCode(type); // Resets the dirty flag
         }
@@ -347,8 +346,8 @@ private slots:
 
         // THEN
         QVERIFY(backend.enabledLayers().isEmpty());
-        for (int i = 0; i <= Qt3DRender::Render::ShaderBuilder::Compute; i++) {
-            const auto type = static_cast<Qt3DRender::Render::ShaderBuilder::ShaderType>(i);
+        for (int i = 0; i <= Qt3DRender::QShaderProgram::Compute; i++) {
+            const auto type = static_cast<Qt3DRender::QShaderProgram::ShaderType>(i);
             QVERIFY(!backend.isShaderCodeDirty(type));
             backend.generateCode(type); // Resets the dirty flag
         }
@@ -358,32 +357,32 @@ private slots:
 
     void shouldHandleShaderGraphPropertiesChanges_data()
     {
-        QTest::addColumn<Qt3DRender::Render::ShaderBuilder::ShaderType>("type");
+        QTest::addColumn<Qt3DRender::QShaderProgram::ShaderType>("type");
         QTest::addColumn<QUrl>("graphUrl");
 
-        QTest::newRow("vertex") << Qt3DRender::Render::ShaderBuilder::Vertex
+        QTest::newRow("vertex") << Qt3DRender::QShaderProgram::Vertex
                                 << QUrl::fromEncoded("qrc:/vertex.json");
 
-        QTest::newRow("tessControl") << Qt3DRender::Render::ShaderBuilder::TessellationControl
+        QTest::newRow("tessControl") << Qt3DRender::QShaderProgram::TessellationControl
                                      << QUrl::fromEncoded("qrc:/tesscontrol.json");
 
-        QTest::newRow("tessEval") << Qt3DRender::Render::ShaderBuilder::TessellationEvaluation
+        QTest::newRow("tessEval") << Qt3DRender::QShaderProgram::TessellationEvaluation
                                   << QUrl::fromEncoded("qrc:/tesseval.json");
 
-        QTest::newRow("geometry") << Qt3DRender::Render::ShaderBuilder::Geometry
+        QTest::newRow("geometry") << Qt3DRender::QShaderProgram::Geometry
                                   << QUrl::fromEncoded("qrc:/geometry.json");
 
-        QTest::newRow("fragment") << Qt3DRender::Render::ShaderBuilder::Fragment
+        QTest::newRow("fragment") << Qt3DRender::QShaderProgram::Fragment
                                   << QUrl::fromEncoded("qrc:/fragment.json");
 
-        QTest::newRow("compute") << Qt3DRender::Render::ShaderBuilder::Compute
+        QTest::newRow("compute") << Qt3DRender::QShaderProgram::Compute
                                  << QUrl::fromEncoded("qrc:/compute.json");
     }
 
     void shouldHandleShaderGraphPropertiesChanges()
     {
         // GIVEN
-        QFETCH(Qt3DRender::Render::ShaderBuilder::ShaderType, type);
+        QFETCH(Qt3DRender::QShaderProgram::ShaderType, type);
         QFETCH(QUrl, graphUrl);
 
         Qt3DRender::Render::ShaderBuilder backend;
@@ -393,16 +392,16 @@ private slots:
         simulateInitializationSync(&frontend, &backend);
 
         static const QHash<
-                Qt3DRender::Render::ShaderBuilder::ShaderType,
+                Qt3DRender::QShaderProgram::ShaderType,
                 void (Qt3DRender::QShaderProgramBuilder::*)(const QUrl &)
                 >
                 shaderTypesToSetters = {
-            {Qt3DRender::Render::ShaderBuilder::Vertex, &Qt3DRender::QShaderProgramBuilder::setVertexShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::TessellationControl, &Qt3DRender::QShaderProgramBuilder::setTessellationControlShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::TessellationEvaluation, &Qt3DRender::QShaderProgramBuilder::setTessellationEvaluationShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Geometry, &Qt3DRender::QShaderProgramBuilder::setGeometryShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Fragment, &Qt3DRender::QShaderProgramBuilder::setFragmentShaderGraph},
-            {Qt3DRender::Render::ShaderBuilder::Compute, &Qt3DRender::QShaderProgramBuilder::setComputeShaderGraph},
+            {Qt3DRender::QShaderProgram::Vertex, &Qt3DRender::QShaderProgramBuilder::setVertexShaderGraph},
+            {Qt3DRender::QShaderProgram::TessellationControl, &Qt3DRender::QShaderProgramBuilder::setTessellationControlShaderGraph},
+            {Qt3DRender::QShaderProgram::TessellationEvaluation, &Qt3DRender::QShaderProgramBuilder::setTessellationEvaluationShaderGraph},
+            {Qt3DRender::QShaderProgram::Geometry, &Qt3DRender::QShaderProgramBuilder::setGeometryShaderGraph},
+            {Qt3DRender::QShaderProgram::Fragment, &Qt3DRender::QShaderProgramBuilder::setFragmentShaderGraph},
+            {Qt3DRender::QShaderProgram::Compute, &Qt3DRender::QShaderProgramBuilder::setComputeShaderGraph},
         };
 
         // WHEN
@@ -455,14 +454,14 @@ private slots:
 
     void shouldHandleShaderCodeGeneration_data()
     {
-        QTest::addColumn<Qt3DRender::Render::ShaderBuilder::ShaderType>("type");
-
-        QTest::newRow("vertex") << Qt3DRender::Render::ShaderBuilder::Vertex;
-        QTest::newRow("tessControl") << Qt3DRender::Render::ShaderBuilder::TessellationControl;
-        QTest::newRow("tessEval") << Qt3DRender::Render::ShaderBuilder::TessellationEvaluation;
-        QTest::newRow("geometry") << Qt3DRender::Render::ShaderBuilder::Geometry;
-        QTest::newRow("fragment") << Qt3DRender::Render::ShaderBuilder::Fragment;
-        QTest::newRow("compute") << Qt3DRender::Render::ShaderBuilder::Compute;
+        QTest::addColumn<Qt3DRender::QShaderProgram::ShaderType>("type");
+
+        QTest::newRow("vertex") << Qt3DRender::QShaderProgram::Vertex;
+        QTest::newRow("tessControl") << Qt3DRender::QShaderProgram::TessellationControl;
+        QTest::newRow("tessEval") << Qt3DRender::QShaderProgram::TessellationEvaluation;
+        QTest::newRow("geometry") << Qt3DRender::QShaderProgram::Geometry;
+        QTest::newRow("fragment") << Qt3DRender::QShaderProgram::Fragment;
+        QTest::newRow("compute") << Qt3DRender::QShaderProgram::Compute;
     }
 
     void shouldHandleShaderCodeGeneration()
@@ -471,7 +470,7 @@ private slots:
         Qt3DRender::Render::ShaderBuilder::setPrototypesFile(":/prototypes.json");
         QVERIFY(!Qt3DRender::Render::ShaderBuilder::getPrototypeNames().isEmpty());
 
-        QFETCH(Qt3DRender::Render::ShaderBuilder::ShaderType, type);
+        QFETCH(Qt3DRender::QShaderProgram::ShaderType, type);
 
         const auto gl3Api = []{
             auto api = Qt3DRender::GraphicsApiFilterData();
@@ -540,15 +539,15 @@ private slots:
 
     void checkCodeUpdatedNotification_data()
     {
-        QTest::addColumn<Qt3DRender::Render::ShaderBuilder::ShaderType>("type");
+        QTest::addColumn<Qt3DRender::QShaderProgram::ShaderType>("type");
         QTest::addColumn<Qt3DRender::QShaderProgram::ShaderType>("notificationType");
 
-        QTest::newRow("vertex") << Qt3DRender::Render::ShaderBuilder::Vertex << Qt3DRender::QShaderProgram::Vertex;
-        QTest::newRow("tessControl") << Qt3DRender::Render::ShaderBuilder::TessellationControl << Qt3DRender::QShaderProgram::TessellationControl;
-        QTest::newRow("tessEval") << Qt3DRender::Render::ShaderBuilder::TessellationEvaluation << Qt3DRender::QShaderProgram::TessellationEvaluation;
-        QTest::newRow("geometry") << Qt3DRender::Render::ShaderBuilder::Geometry << Qt3DRender::QShaderProgram::Geometry;
-        QTest::newRow("fragment") << Qt3DRender::Render::ShaderBuilder::Fragment << Qt3DRender::QShaderProgram::Fragment;
-        QTest::newRow("compute") << Qt3DRender::Render::ShaderBuilder::Compute << Qt3DRender::QShaderProgram::Compute;
+        QTest::newRow("vertex") << Qt3DRender::QShaderProgram::Vertex << Qt3DRender::QShaderProgram::Vertex;
+        QTest::newRow("tessControl") << Qt3DRender::QShaderProgram::TessellationControl << Qt3DRender::QShaderProgram::TessellationControl;
+        QTest::newRow("tessEval") << Qt3DRender::QShaderProgram::TessellationEvaluation << Qt3DRender::QShaderProgram::TessellationEvaluation;
+        QTest::newRow("geometry") << Qt3DRender::QShaderProgram::Geometry << Qt3DRender::QShaderProgram::Geometry;
+        QTest::newRow("fragment") << Qt3DRender::QShaderProgram::Fragment << Qt3DRender::QShaderProgram::Fragment;
+        QTest::newRow("compute") << Qt3DRender::QShaderProgram::Compute << Qt3DRender::QShaderProgram::Compute;
     }
 
 
@@ -559,7 +558,7 @@ private slots:
 
         Qt3DRender::Render::ShaderBuilder::setPrototypesFile(":/prototypes.json");
         QVERIFY(!Qt3DRender::Render::ShaderBuilder::getPrototypeNames().isEmpty());
-        QFETCH(Qt3DRender::Render::ShaderBuilder::ShaderType, type);
+        QFETCH(Qt3DRender::QShaderProgram::ShaderType, type);
         QFETCH(Qt3DRender::QShaderProgram::ShaderType, notificationType);
 
         const auto gl3Api = []{
@@ -603,15 +602,6 @@ private slots:
         QCOMPARE(backend.shaderGraph(type), graphUrl);
         QVERIFY(!backend.isShaderCodeDirty(type));
         QCOMPARE(backend.shaderCode(type), gl3Code);
-
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(arbiter.events.count(), 1);
-        QCOMPARE(change->propertyName(), "generatedShaderCode");
-        const QPair<int, QByteArray> value = change->value().value<QPair<int, QByteArray>>();
-        QCOMPARE(value.first, int(notificationType));
-        QCOMPARE(value.second, gl3Code);
-
-        arbiter.events.clear();
     }
 };
 
diff --git a/tests/manual/compressed_textures/compressed_textures.pro b/tests/manual/compressed_textures/compressed_textures.pro
new file mode 100644
index 000000000..37871a4cb
--- /dev/null
+++ b/tests/manual/compressed_textures/compressed_textures.pro
@@ -0,0 +1,12 @@
+QT += 3dcore 3drender 3dinput 3dquick 3dlogic qml quick 3dquickextras
+
+SOURCES += \
+    main.cpp
+
+OTHER_FILES += \
+    main.qml
+
+RESOURCES += \
+    compressed_textures.qrc
+
+DEFINES += DATA_DIR=\\\"$$PWD/data\\\"
diff --git a/tests/manual/compressed_textures/compressed_textures.qrc b/tests/manual/compressed_textures/compressed_textures.qrc
new file mode 100644
index 000000000..5f6483ac3
--- /dev/null
+++ b/tests/manual/compressed_textures/compressed_textures.qrc
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>main.qml</file>
+    </qresource>
+</RCC>
diff --git a/tests/manual/compressed_textures/data/16_16.png b/tests/manual/compressed_textures/data/16_16.png
new file mode 100644
index 000000000..aefb48dc4
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16.png
diff --git a/tests/manual/compressed_textures/data/16_16_PNG_ASTC_7.KTX b/tests/manual/compressed_textures/data/16_16_PNG_ASTC_7.KTX
new file mode 100644
index 000000000..953f300ad
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16_PNG_ASTC_7.KTX
diff --git a/tests/manual/compressed_textures/data/16_16_PNG_ASTC_8.KTX b/tests/manual/compressed_textures/data/16_16_PNG_ASTC_8.KTX
new file mode 100644
index 000000000..4c23241e4
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16_PNG_ASTC_8.KTX
diff --git a/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGBA_11.KTX b/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGBA_11.KTX
new file mode 100644
index 000000000..01646e99a
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGBA_11.KTX
diff --git a/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGB_13.KTX b/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGB_13.KTX
new file mode 100644
index 000000000..2d2efff1b
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16_PNG_ETC2_RGB_13.KTX
diff --git a/tests/manual/compressed_textures/data/16_16_PNG_ETC_RGB_12.KTX b/tests/manual/compressed_textures/data/16_16_PNG_ETC_RGB_12.KTX
new file mode 100644
index 000000000..15e30abc8
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16_16_PNG_ETC_RGB_12.KTX
diff --git a/tests/manual/compressed_textures/data/16x16-etc1.pkm b/tests/manual/compressed_textures/data/16x16-etc1.pkm
new file mode 100644
index 000000000..62ae2a11f
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16-etc1.pkm
diff --git a/tests/manual/compressed_textures/data/16x16-etc2.pkm b/tests/manual/compressed_textures/data/16x16-etc2.pkm
new file mode 100644
index 000000000..be391113e
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16-etc2.pkm
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc1-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc1-dx10.dds
new file mode 100644
index 000000000..feacae8d1
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc1-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips-dx10.dds
new file mode 100644
index 000000000..40da98cde
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips.dds
new file mode 100644
index 000000000..1dd3e1e91
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc1-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc1.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc1.dds
new file mode 100644
index 000000000..e31f410d2
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc1.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc3-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc3-dx10.dds
new file mode 100644
index 000000000..76c820f31
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc3-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips-dx10.dds
new file mode 100644
index 000000000..0a2964f12
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips.dds
new file mode 100644
index 000000000..c8c94d85f
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc3-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-bc3.dds b/tests/manual/compressed_textures/data/16x16x1-1-bc3.dds
new file mode 100644
index 000000000..4a08d324a
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-bc3.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-lumi-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-1-lumi-nomips.dds
new file mode 100644
index 000000000..8fdd5e3e1
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-lumi-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-lumi.dds b/tests/manual/compressed_textures/data/16x16x1-1-lumi.dds
new file mode 100644
index 000000000..82ab57958
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-lumi.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-rgb-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-1-rgb-nomips.dds
new file mode 100644
index 000000000..94d06c2c4
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-rgb-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-1-rgb.dds b/tests/manual/compressed_textures/data/16x16x1-1-rgb.dds
new file mode 100644
index 000000000..45635dd97
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-1-rgb.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc1-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc1-dx10.dds
new file mode 100644
index 000000000..209b796f0
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc1-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips-dx10.dds
new file mode 100644
index 000000000..e79e29ab5
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips.dds
new file mode 100644
index 000000000..de6796d9f
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc1-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc1.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc1.dds
new file mode 100644
index 000000000..92b95ae73
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc1.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc3-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc3-dx10.dds
new file mode 100644
index 000000000..f56fa09fd
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc3-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips-dx10.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips-dx10.dds
new file mode 100644
index 000000000..31e137553
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips-dx10.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips.dds
new file mode 100644
index 000000000..644274601
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc3-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-bc3.dds b/tests/manual/compressed_textures/data/16x16x1-6-bc3.dds
new file mode 100644
index 000000000..144515bb0
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-bc3.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-lumi-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-6-lumi-nomips.dds
new file mode 100644
index 000000000..baa884a36
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-lumi-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-lumi.dds b/tests/manual/compressed_textures/data/16x16x1-6-lumi.dds
new file mode 100644
index 000000000..1a4e6f46f
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-lumi.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-rgb-nomips.dds b/tests/manual/compressed_textures/data/16x16x1-6-rgb-nomips.dds
new file mode 100644
index 000000000..318a0bd35
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-rgb-nomips.dds
diff --git a/tests/manual/compressed_textures/data/16x16x1-6-rgb.dds b/tests/manual/compressed_textures/data/16x16x1-6-rgb.dds
new file mode 100644
index 000000000..1f3c8f9cf
--- /dev/null
+++ b/tests/manual/compressed_textures/data/16x16x1-6-rgb.dds
diff --git a/tests/manual/compressed_textures/main.cpp b/tests/manual/compressed_textures/main.cpp
new file mode 100644
index 000000000..ca4cf7c2d
--- /dev/null
+++ b/tests/manual/compressed_textures/main.cpp
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 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:BSD$
+** 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.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QQuickView>
+#include <QGuiApplication>
+#include <QQmlContext>
+#include <QDir>
+
+QStringList createTextureFileList()
+{
+    QDir dir(QString::fromUtf8(DATA_DIR));
+    return dir.entryList();
+}
+
+int main(int argc, char* argv[])
+{
+    QGuiApplication app(argc, argv);
+    QQuickView view;
+
+    QQmlContext *ctx =view.rootContext();
+    ctx->setContextProperty(QStringLiteral("_pathPrefix"), QString::fromUtf8(DATA_DIR));
+    ctx->setContextProperty(QStringLiteral("_texturesList"), createTextureFileList());
+
+    view.setSource(QUrl("qrc:/main.qml"));
+    view.show();
+
+    return app.exec();
+}
diff --git a/tests/manual/compressed_textures/main.qml b/tests/manual/compressed_textures/main.qml
new file mode 100644
index 000000000..b5ad0990e
--- /dev/null
+++ b/tests/manual/compressed_textures/main.qml
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 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:BSD$
+** 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.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.12 as QQ2
+import QtQuick.Scene3D 2.12
+import QtQuick.Controls 2.12
+import Qt3D.Core 2.12
+import Qt3D.Render 2.12
+import Qt3D.Input 2.12
+import Qt3D.Extras 2.12
+
+QQ2.Item {
+    id: root
+    width: 1280
+    height: 720
+
+    readonly property string textureSource: "file://" + _pathPrefix + "/" + textureSelector.textAt(textureSelector.currentIndex)
+
+    Scene3D {
+        anchors.fill: parent
+        focus: true
+        aspects: ["input", "logic"]
+
+        Entity {
+            id: sceneRoot
+
+            Camera {
+                id: camera
+                projectionType: CameraLens.PerspectiveProjection
+                fieldOfView: 45
+                aspectRatio: 16/9
+                nearPlane : 0.1
+                farPlane : 1000.0
+                position: Qt.vector3d(0.0, 0.0, -2.0)
+                upVector: Qt.vector3d(0.0, 1.0, 0.0)
+                viewCenter: Qt.vector3d(0.0, 0.0, 0.0)
+            }
+
+            OrbitCameraController {
+                camera: camera
+            }
+
+            components: [
+                RenderSettings {
+                    activeFrameGraph: ForwardRenderer {
+                        clearColor: Qt.rgba(0, 0.5, 1, 1)
+                        camera: camera
+                    }
+                },
+                // Event Source will be set by the Qt3DQuickWindow
+                InputSettings { }
+            ]
+
+            Entity {
+                readonly property CuboidMesh mesh: CuboidMesh { }
+                readonly property DiffuseMapMaterial material: DiffuseMapMaterial {
+                    diffuse: TextureLoader {
+                        source: textureSource
+                    }
+                }
+                components: [ mesh, material ]
+            }
+        }
+    }
+
+    ComboBox {
+        id: textureSelector
+        model: _texturesList
+        width: 200
+    }
+}
diff --git a/tests/manual/manual.pro b/tests/manual/manual.pro
index 644c9ecf9..1182886d3 100644
--- a/tests/manual/manual.pro
+++ b/tests/manual/manual.pro
@@ -66,7 +66,8 @@ SUBDIRS += \
     qtbug-72236 \
     qtbug-76766 \
     shader-image-qml \
-    scene3d-in-sync
+    scene3d-in-sync \
+    compressed_textures
 
 qtHaveModule(multimedia): {
     SUBDIRS += \