Merge remote-tracking branch 'origin/5.10' into 5.11

Conflicts:
	src/animation/doc/src/qt3danimation-module.qdoc
	src/render/backend/abstractrenderer_p.h
	src/render/backend/buffervisitor_p.h
	src/render/backend/renderer.cpp
	src/render/backend/renderer_p.h
	src/render/backend/triangleboundingvolume_p.h
	src/render/backend/trianglesextractor_p.h
	src/render/frontend/sphere_p.h
	src/render/jobs/calcboundingvolumejob.cpp
	src/render/jobs/job_common_p.h
	src/render/jobs/pickboundingvolumejob.cpp
	src/render/jobs/pickboundingvolumejob_p.h
	src/render/jobs/pickboundingvolumeutils.cpp
	src/render/jobs/renderviewjobutils_p.h
	tests/auto/render/boundingsphere/tst_boundingsphere.cpp
	tests/auto/render/commons/testrenderer.h
	tests/auto/render/raycasting/tst_raycasting.cpp
	tests/auto/render/render.pro
	tests/auto/render/renderer/tst_renderer.cpp

Change-Id: I76633bc5a5a065e5f9ea62cc16563377e5c693a3

35 files changed, 1400 insertions, 527 deletions

diff --git a/tests/auto/core/common/common.pri b/tests/auto/core/common/common.pri
index 3a85df875..9b761b8e0 100644
--- a/tests/auto/core/common/common.pri
+++ b/tests/auto/core/common/common.pri
@@ -15,3 +15,13 @@ qtConfig(private_tests) {
 }
 
 QT += core-private 3dcore 3dcore-private
+
+qtConfig(qt3d-simd-avx2) {
+    CONFIG += simd
+    QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_AVX2
+}
+
+qtConfig(qt3d-simd-sse2):!qtConfig(qt3d-simd-avx2) {
+    CONFIG += simd
+    QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_SSE2
+}
diff --git a/tests/auto/core/matrix4x4_avx2/matrix4x4_avx2.pro b/tests/auto/core/matrix4x4_avx2/matrix4x4_avx2.pro
index 4a97ab2a9..4db8a1975 100644
--- a/tests/auto/core/matrix4x4_avx2/matrix4x4_avx2.pro
+++ b/tests/auto/core/matrix4x4_avx2/matrix4x4_avx2.pro
@@ -1,6 +1,6 @@
 TARGET = tst_matrix4x4_avx2
 CONFIG += testcase
-QT += testlib 3dcore 3dcore-private
+QT += testlib 3dcore 3dcore-private 3drender-private
 
 QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_AVX2
 
diff --git a/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp b/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
index 41b0c535c..144df6711 100644
--- a/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
+++ b/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
@@ -28,12 +28,15 @@
 
 #include <QtTest/QtTest>
 #include <Qt3DCore/private/matrix4x4_avx2_p.h>
+#include <Qt3DRender/private/aligned_malloc_p.h>
 
 using namespace Qt3DCore;
 
 class tst_Matrix4x4_AVX2: public QObject
 {
     Q_OBJECT
+public:
+    QT3D_ALIGNED_MALLOC_AND_FREE()
 
 private Q_SLOTS:
 
diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp
index 2e73e6c34..baf7010b0 100644
--- a/tests/auto/core/nodes/tst_nodes.cpp
+++ b/tests/auto/core/nodes/tst_nodes.cpp
@@ -1041,15 +1041,22 @@ void tst_Nodes::appendingParentlessComponentToEntity()
         // return early in such a case.
 
         // Check that we received ComponentAdded
-        for (const auto event: { entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>(),
-                                 componentSpy.events.takeLast().change().dynamicCast<Qt3DCore::QComponentAddedChange>() })
         {
+            const auto event = entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>();
             QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
             QCOMPARE(event->subjectId(), entity->id());
             QCOMPARE(event->entityId(), entity->id());
             QCOMPARE(event->componentId(), comp->id());
             QCOMPARE(event->componentMetaObject(), comp->metaObject());
         }
+        {
+            const auto event = componentSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>();
+            QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
+            QCOMPARE(event->subjectId(), comp->id());
+            QCOMPARE(event->entityId(), entity->id());
+            QCOMPARE(event->componentId(), comp->id());
+            QCOMPARE(event->componentMetaObject(), comp->metaObject());
+        }
     }
 }
 
@@ -1080,15 +1087,22 @@ void tst_Nodes::appendingComponentToEntity()
         QVERIFY(comp->parentNode() == entity.data());
         QCOMPARE(entitySpy.events.size(), 1);
         QVERIFY(entitySpy.events.first().wasLocked());
-        for (const auto event: { entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>(),
-             componentSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>() })
         {
+            const auto event = entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>();
             QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
             QCOMPARE(event->subjectId(), entity->id());
             QCOMPARE(event->entityId(), entity->id());
             QCOMPARE(event->componentId(), comp->id());
             QCOMPARE(event->componentMetaObject(), comp->metaObject());
         }
+        {
+            const auto event = componentSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentAddedChange>();
+            QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
+            QCOMPARE(event->subjectId(), comp->id());
+            QCOMPARE(event->entityId(), entity->id());
+            QCOMPARE(event->componentId(), comp->id());
+            QCOMPARE(event->componentMetaObject(), comp->metaObject());
+        }
     }
 }
 
@@ -1123,14 +1137,22 @@ void tst_Nodes::removingComponentFromEntity()
         QCOMPARE(entitySpy.events.size(), 1);
         QVERIFY(entitySpy.events.first().wasLocked());
         QCOMPARE(componentSpy.events.size(), 1);
-        for (const auto event: { entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentRemovedChange>(),
-                                 componentSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentRemovedChange>() }) {
+        {
+            const auto event = entitySpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentRemovedChange>();
             QCOMPARE(event->type(), Qt3DCore::ComponentRemoved);
             QCOMPARE(event->subjectId(), entity->id());
             QCOMPARE(event->entityId(), entity->id());
             QCOMPARE(event->componentId(), comp->id());
             QCOMPARE(event->componentMetaObject(), comp->metaObject());
         }
+        {
+            const auto event = componentSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QComponentRemovedChange>();
+            QCOMPARE(event->type(), Qt3DCore::ComponentRemoved);
+            QCOMPARE(event->subjectId(), comp->id());
+            QCOMPARE(event->entityId(), entity->id());
+            QCOMPARE(event->componentId(), comp->id());
+            QCOMPARE(event->componentMetaObject(), comp->metaObject());
+        }
     }
 }
 
diff --git a/tests/auto/core/vector3d_sse/tst_vector3d_sse.cpp b/tests/auto/core/vector3d_sse/tst_vector3d_sse.cpp
index be9fbc347..7ea79a5f5 100644
--- a/tests/auto/core/vector3d_sse/tst_vector3d_sse.cpp
+++ b/tests/auto/core/vector3d_sse/tst_vector3d_sse.cpp
@@ -668,6 +668,14 @@ private Q_SLOTS:
             // THEN
             QVERIFY(v0 == v1);
         }
+        {
+            // GIVEN
+            Vector3D_SSE v0(6.0f, 6.0f, 6.0f);
+            Vector3D_SSE v1(6.0f, 6.0f, 6.0f);
+
+            // THEN
+            QVERIFY(v0 == v1);
+        }
     }
 
     void checkInequality()
@@ -787,11 +795,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkNormalized()
-    {
-
-    }
-
     void checkIsNull()
     {
         {
diff --git a/tests/auto/core/vector4d_sse/tst_vector4d_sse.cpp b/tests/auto/core/vector4d_sse/tst_vector4d_sse.cpp
index e7b58c8cf..ed9722ffb 100644
--- a/tests/auto/core/vector4d_sse/tst_vector4d_sse.cpp
+++ b/tests/auto/core/vector4d_sse/tst_vector4d_sse.cpp
@@ -823,6 +823,98 @@ private Q_SLOTS:
             QCOMPARE(v0.w(), v1.w());
         }
     }
+
+    void checkLengthSquared()
+    {
+        {
+            // GIVEN
+            Vector4D_SSE v0(10.0f, 10.0f, 10.0f, 10.0f);
+
+            // THEN
+            QCOMPARE(v0.lengthSquared(), 400.0f);
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(3.0f, 1.0f, 2.0f, 4.0f);
+
+            // THEN
+            QCOMPARE(v0.lengthSquared(), 30.0f);
+        }
+    }
+
+    void checkLength()
+    {
+        {
+            // GIVEN
+            Vector4D_SSE v0(3.0f, 0.0f, 0.0f, 0.0f);
+
+            // THEN
+            QCOMPARE(v0.length(), 3.0f);
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(0.0f, 10.0f, 0.0f, 0.0f);
+
+            // THEN
+            QCOMPARE(v0.length(), 10.0f);
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(0.0f, 0.0f, 9.0f, 0.0f);
+
+            // THEN
+            QCOMPARE(v0.length(), 9.0f);
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(0.0f, 0.0f, 0.0f, 8.0f);
+
+            // THEN
+            QCOMPARE(v0.length(), 8.0f);
+        }
+    }
+
+    void checkNormalize()
+    {
+        {
+            // GIVEN
+            Vector4D_SSE v0(10.0f, 0.0f, 0.0f, 0.0f);
+
+            // WHEN
+            v0.normalize();
+
+            // THEN
+            QCOMPARE(v0, Vector4D_SSE(1.0f, 0.0f, 0.0f, 0.0f));
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(0.0f, 0.0f, 3.0f, 0.0f);
+
+            // WHEN
+            v0.normalize();
+
+            // THEN
+            QCOMPARE(v0, Vector4D_SSE(0.0, 0.0f, 1.0f, 0.0f));
+        }
+    }
+
+    void checkIsNull()
+    {
+        {
+            // GIVEN
+            Vector4D_SSE v0;
+
+            // THEN
+            QVERIFY(v0.isNull());
+        }
+        {
+            // GIVEN
+            Vector4D_SSE v0(1.0f, 1.0f, 1.0f, 1.0f);
+
+            // THEN
+            QVERIFY(!v0.isNull());
+        }
+    }
 };
 
 QTEST_APPLESS_MAIN(tst_Vector4D_SSE)
diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index ce55db432..992e643d2 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -330,7 +330,98 @@ private Q_SLOTS:
         calcBVolume.setRoot(test->sceneRoot());
         calcBVolume.run();
 
-        QVector3D center = entityBackend->localBoundingVolume()->center();
+        Vector3D center = entityBackend->localBoundingVolume()->center();
+        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()));
+    }
+
+    void checkCustomPackedGeometry()
+    {
+        int drawVertexCount = 6;
+        QVector3D expectedCenter(-0.488892f, 0.0192147f, -75.4804f);
+        float expectedRadius = 25.5442f;
+
+        // two triangles with different Z
+        QByteArray vdata;
+        vdata.resize(6 * 3 * sizeof(float));
+        float *vp = reinterpret_cast<float *>(vdata.data());
+        *vp++ = -1.0f;
+        *vp++ = 1.0f;
+        *vp++ = -100.0f;
+        *vp++ = 0.0f;
+        *vp++ = 0.0f;
+        *vp++ = -100.0f;
+        *vp++ = 1.0f;
+        *vp++ = 1.0f;
+        *vp++ = -100.0f;
+
+        *vp++ = -1.0f;
+        *vp++ = -1.0f;
+        *vp++ = -50.0f;
+        *vp++ = 0.0f;
+        *vp++ = 0.0f;
+        *vp++ = -50.0f;
+        *vp++ = 1.0f;
+        *vp++ = -1.0f;
+        *vp++ = -50.0f;
+
+        QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity);
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(entity.data()));
+        Qt3DRender::QBuffer *vbuffer = new Qt3DRender::QBuffer;
+
+        vbuffer->setData(vdata);
+        Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
+        vbufferBackend->setRenderer(test->renderer());
+        vbufferBackend->setManager(test->nodeManagers()->bufferManager());
+        simulateInitialization(vbuffer, vbufferBackend);
+
+        Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry;
+        g->addAttribute(new Qt3DRender::QAttribute);
+
+        const QVector<Qt3DRender::QAttribute *> attrs = g->attributes();
+        Qt3DRender::QAttribute *attr = attrs[0];
+        attr->setBuffer(vbuffer);
+        attr->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
+        attr->setVertexBaseType(Qt3DRender::QAttribute::Float);
+        attr->setVertexSize(3);
+        attr->setCount(6);
+        attr->setByteOffset(0);
+        attr->setByteStride(0);
+
+        Qt3DRender::QGeometryRenderer *gr = new Qt3DRender::QGeometryRenderer;
+        gr->setVertexCount(drawVertexCount);
+        gr->setGeometry(g);
+        entity->addComponent(gr);
+
+        Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
+        attr0Backend->setRenderer(test->renderer());
+        simulateInitialization(attrs[0], attr0Backend);
+
+        Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
+        gBackend->setRenderer(test->renderer());
+        simulateInitialization(g, gBackend);
+
+        Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
+        grBackend->setRenderer(test->renderer());
+        grBackend->setManager(test->nodeManagers()->geometryRendererManager());
+        simulateInitialization(gr, grBackend);
+
+        Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
+        entityBackend->setRenderer(test->renderer());
+        simulateInitialization(entity.data(), entityBackend);
+
+        Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
+        calcBVolume.setManagers(test->nodeManagers());
+        calcBVolume.setRoot(test->sceneRoot());
+        calcBVolume.run();
+
+        Vector3D center = entityBackend->localBoundingVolume()->center();
         float radius = entityBackend->localBoundingVolume()->radius();
         qDebug() << radius << center;
 
diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index b3f602dc2..9624f129a 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -52,7 +52,7 @@ public:
     void shutdown() override {}
     void releaseGraphicsResources() override {}
     void render() override {}
-    void doRender(bool scene3dBlocking = false) override { Q_UNUSED(scene3dBlocking); }
+    void doRender() override {}
     void cleanGraphicsResources() override {}
     bool isRunning() const override { return true; }
     bool shouldRender() override { return true; }
@@ -60,7 +60,7 @@ public:
     QVector<Qt3DCore::QAspectJobPtr> renderBinJobs() override { return QVector<Qt3DCore::QAspectJobPtr>(); }
     Qt3DCore::QAspectJobPtr pickBoundingVolumeJob() override { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr rayCastingJob() override { return Qt3DCore::QAspectJobPtr(); }
-    Qt3DCore::QAspectJobPtr syncTextureLoadingJob() override { return Qt3DCore::QAspectJobPtr(); }
+    Qt3DCore::QAspectJobPtr syncSkeletonLoadingJob() override { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() override { return Qt3DCore::QAspectJobPtr(); }
     void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Qt3DRender::Render::Entity *root) override { Q_UNUSED(factory);  Q_UNUSED(root); }
     Qt3DRender::Render::Entity *sceneRoot() const override { return nullptr; }
@@ -81,6 +81,12 @@ public:
     void setOffscreenSurfaceHelper(Qt3DRender::Render::OffscreenSurfaceHelper *helper) override;
     QSurfaceFormat format() override;
 
+    void lockSurfaceAndRender() override {}
+    bool releaseRendererAndRequestPromiseToRender() override { return true; }
+    bool waitForRenderJobs() override { return true; }
+    bool tryWaitForRenderJobs(int timeout) override { Q_UNUSED(timeout); return true; }
+    void abortRenderJobs() override {}
+
 protected:
     Qt3DRender::Render::AbstractRenderer::BackendNodeDirtySet m_changes;
     Qt3DRender::Render::NodeManagers *m_managers;
diff --git a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
index 7dfe3ceba..afb18fe55 100644
--- a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
+++ b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
@@ -67,7 +67,7 @@ public:
     {
         return m_bufferInfo;
     }
-    bool verifyCoordinate(uint index, QVector4D value)
+    bool verifyCoordinate(uint index, Vector4D value)
     {
         return qFuzzyCompare(getCoordinate(index), value);
     }
@@ -270,12 +270,12 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(ret, true);
 
-        QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1)));
-        QVERIFY(reader.verifyCoordinate(1, QVector4D(1, 0, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(3, QVector4D(0, 0, 1, 1)));
-        QVERIFY(reader.verifyCoordinate(4, QVector4D(1, 0, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(5, QVector4D(0, 1, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(0, Vector4D(0, 0, 1, 1)));
+        QVERIFY(reader.verifyCoordinate(1, Vector4D(1, 0, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(2, Vector4D(0, 1, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(3, Vector4D(0, 0, 1, 1)));
+        QVERIFY(reader.verifyCoordinate(4, Vector4D(1, 0, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(5, Vector4D(0, 1, 0, 1)));
     }
 
     void testReadCoordinateVec4()
@@ -364,12 +364,12 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(ret, true);
 
-        QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1)));
-        QVERIFY(reader.verifyCoordinate(1, QVector4D(1, 0, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 0)));
-        QVERIFY(reader.verifyCoordinate(3, QVector4D(0, 0, 1, 0)));
-        QVERIFY(reader.verifyCoordinate(4, QVector4D(1, 0, 0, 0)));
-        QVERIFY(reader.verifyCoordinate(5, QVector4D(0, 1, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(0, Vector4D(0, 0, 1, 1)));
+        QVERIFY(reader.verifyCoordinate(1, Vector4D(1, 0, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(2, Vector4D(0, 1, 0, 0)));
+        QVERIFY(reader.verifyCoordinate(3, Vector4D(0, 0, 1, 0)));
+        QVERIFY(reader.verifyCoordinate(4, Vector4D(1, 0, 0, 0)));
+        QVERIFY(reader.verifyCoordinate(5, Vector4D(0, 1, 0, 1)));
     }
 
     void testReadCoordinateFromAttribute()
@@ -468,9 +468,9 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(ret, true);
 
-        QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1)));
-        QVERIFY(reader.verifyCoordinate(1, QVector4D(0, 1, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(2, QVector4D(1, 0, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(0, Vector4D(0, 0, 1, 1)));
+        QVERIFY(reader.verifyCoordinate(1, Vector4D(0, 1, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(2, Vector4D(1, 0, 0, 1)));
 
         // WHEN
         ret = reader.setGeometry(backendRenderer,
@@ -479,9 +479,9 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(ret, true);
 
-        QVERIFY(reader.verifyCoordinate(0, QVector4D(1, 0, 0, 1)));
-        QVERIFY(reader.verifyCoordinate(1, QVector4D(0, 0, 1, 1)));
-        QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(0, Vector4D(1, 0, 0, 1)));
+        QVERIFY(reader.verifyCoordinate(1, Vector4D(0, 0, 1, 1)));
+        QVERIFY(reader.verifyCoordinate(2, Vector4D(0, 1, 0, 1)));
     }
 
 };
diff --git a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
index 4d4a08a34..803d57fa9 100644
--- a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
+++ b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
@@ -93,7 +93,8 @@ public:
     {
         renderer()->setOpenGLContext(&m_glContext);
         d_func()->m_renderer->initialize();
-        renderer()->graphicsContext()->beginDrawing(m_window.data());
+        renderer()->graphicsContext()->makeCurrent(m_window.data());
+        renderer()->graphicsContext()->beginDrawing();
     }
 
     Render::Renderer *renderer() const
diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
index d07ec9914..e61fdf6e5 100644
--- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
+++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
@@ -30,6 +30,7 @@
 #include <qbackendnodetester.h>
 #include <Qt3DRender/private/geometryrenderer_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
+#include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qgeometryfactory.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
@@ -186,6 +187,8 @@ private Q_SLOTS:
         // GIVEN
         Qt3DRender::Render::GeometryRenderer renderGeometryRenderer;
         TestRenderer renderer;
+        Qt3DRender::Render::NodeManagers nodeManagers;
+
         renderGeometryRenderer.setRenderer(&renderer);
 
         QVERIFY(!renderGeometryRenderer.isDirty());
diff --git a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
index c2b0c7fff..feef480e2 100644
--- a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
+++ b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
@@ -8,5 +8,7 @@
         <file>testscene_pickersdisabled.qml</file>
         <file>testscene_dragenabledoverlapping.qml</file>
         <file>testscene_parententity.qml</file>
+        <file>testscene_viewports.qml</file>
+        <file>testscene_cameraposition.qml</file>
     </qresource>
 </RCC>
diff --git a/tests/auto/render/pickboundingvolumejob/testscene_cameraposition.qml b/tests/auto/render/pickboundingvolumejob/testscene_cameraposition.qml
new file mode 100644
index 000000000..87e7a8aac
--- /dev/null
+++ b/tests/auto/render/pickboundingvolumejob/testscene_cameraposition.qml
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 Qt3D.Core 2.0
+import Qt3D.Render 2.0
+import Qt3D.Extras 2.0
+import QtQuick.Window 2.0
+
+Entity {
+    id: sceneRoot
+
+    Window {
+        id: win
+        width: 600
+        height: 600
+        visible: true
+    }
+
+    Camera {
+        id: camera
+        projectionType: CameraLens.PerspectiveProjection
+        fieldOfView: 45
+        nearPlane : 0.1
+        farPlane : 1000.0
+        position: Qt.vector3d( 0.0, 0.0, -40.0 )
+        upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+        viewCenter: Qt.vector3d( 5.0, 3.0, 1.0 )
+    }
+
+    components: [
+        RenderSettings {
+            Viewport {
+                normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
+
+                RenderSurfaceSelector {
+
+                    surface: win
+
+                    ClearBuffers {
+                        buffers : ClearBuffers.ColorDepthBuffer
+                        NoDraw {}
+                    }
+
+                    CameraSelector {
+                        camera: camera
+                    }
+                }
+            }
+        }
+    ]
+
+    CuboidMesh { id: cubeMesh }
+    PhongMaterial { id: material }
+
+    Entity {
+        property ObjectPicker picker: ObjectPicker {
+            objectName: "Picker"
+        }
+
+        property Transform transform: Transform {
+            translation: camera.viewCenter
+            scale: 2.0
+        }
+
+        components: [cubeMesh, material, picker, transform]
+    }
+
+}
diff --git a/tests/auto/render/pickboundingvolumejob/testscene_viewports.qml b/tests/auto/render/pickboundingvolumejob/testscene_viewports.qml
new file mode 100644
index 000000000..daafc0edd
--- /dev/null
+++ b/tests/auto/render/pickboundingvolumejob/testscene_viewports.qml
@@ -0,0 +1,158 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 Qt3D.Core 2.0
+import Qt3D.Render 2.0
+import Qt3D.Extras 2.0
+import QtQuick.Window 2.0
+
+Entity {
+    id: sceneRoot
+
+    Window {
+        id: _view
+        width: 600
+        height: 600
+        visible: true
+    }
+
+    Camera {
+        id: camera
+        projectionType: CameraLens.PerspectiveProjection
+        fieldOfView: 45
+        aspectRatio: _view.width / 2 / _view.height
+        nearPlane : 0.1
+        farPlane : 1000.0
+        position: Qt.vector3d( 0.0, 0.0, -10.0 )
+        upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+        viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
+    }
+
+    Camera {
+        id: camera2
+        projectionType: CameraLens.PerspectiveProjection
+        fieldOfView: 45
+        aspectRatio: _view.width / _view.height
+        nearPlane : 0.1
+        farPlane : 1000.0
+        position: Qt.vector3d( 0.0, 0.0, -20.0 )
+        upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+        viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
+    }
+
+    FirstPersonCameraController {
+        camera: camera
+    }
+
+    DirectionalLight {
+        worldDirection: camera.viewVector.times(-1)
+    }
+
+    // Draw 2 viewports
+    // one with the content, the other with content + debug volumes
+    components: [
+        RenderSettings {
+            Viewport {
+                normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
+
+                RenderSurfaceSelector {
+                    surface: _view
+
+                    Viewport {
+                        normalizedRect: Qt.rect(0.0, 0.0, 0.5, 1.0)
+                        ClearBuffers {
+                            buffers : ClearBuffers.ColorDepthBuffer
+                            clearColor: "white"
+                            CameraSelector {
+                                camera: camera
+                            }
+                        }
+                    }
+
+                    Viewport {
+                        normalizedRect: Qt.rect(0.5, 0.0, 0.5, 1.0)
+                        CameraSelector {
+                            camera: camera2
+                        }
+                    }
+                }
+            }
+        }
+    ]
+
+    CuboidMesh { id: cubeMesh }
+
+    Entity {
+        readonly property ObjectPicker objectPicker: ObjectPicker {
+            onClicked: console.log("o1")
+        }
+        readonly property Transform transform: Transform {
+            scale: 3
+            translation: Qt.vector3d(3, 0, 0)
+        }
+        readonly property PhongMaterial material: PhongMaterial { diffuse: "red" }
+
+        components: [cubeMesh, transform, material, objectPicker ]
+    }
+
+    Entity {
+        readonly property ObjectPicker objectPicker: ObjectPicker {
+            objectName: "Picker2"
+            onClicked: console.log("o2")
+        }
+        readonly property Transform transform: Transform {
+            scale: 3
+            translation: Qt.vector3d(-3, 0, 0)
+        }
+        readonly property PhongMaterial material: PhongMaterial { diffuse: "green" }
+
+        components: [cubeMesh, transform, material, objectPicker ]
+    }
+}
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index a14bccefc..b86df05a4 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -234,7 +234,7 @@ private Q_SLOTS:
 
         // WHEN
         Qt3DRender::Render::PickingUtils::ViewportCameraAreaGatherer gatherer;
-        QVector<Qt3DRender::Render::PickingUtils::ViewportCameraAreaTriplet> results = gatherer.gather(test->frameGraphRoot());
+        QVector<Qt3DRender::Render::PickingUtils::ViewportCameraAreaDetails> results = gatherer.gather(test->frameGraphRoot());
 
         // THEN
         QCOMPARE(results.size(), 1);
@@ -329,8 +329,8 @@ private Q_SLOTS:
         QVERIFY(pickBVJob.currentPicker().isNull());
 
         // WHEN
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *,QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -343,7 +343,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -353,7 +353,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -366,7 +366,7 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -425,8 +425,9 @@ private Q_SLOTS:
         QVERIFY(earlyReturn);
 
         // WHEN
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 440.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 440.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -474,8 +475,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
 
         // THEN
@@ -530,9 +532,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
-                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -580,8 +582,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -591,7 +594,8 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -639,8 +643,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -650,7 +655,8 @@ private Q_SLOTS:
 
         // WHEN
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -698,8 +704,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         const bool earlyReturn = !pickBVJob.runHelper();
 
@@ -764,8 +771,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -785,7 +793,8 @@ private Q_SLOTS:
 
         // WHEN -> Move on same object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -805,7 +814,8 @@ private Q_SLOTS:
 
         // WHEN -> Release on object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -832,8 +842,10 @@ private Q_SLOTS:
 
         // WHEN -> Release outside of object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -900,8 +912,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -916,7 +929,8 @@ private Q_SLOTS:
 
         // WHEN -> HoverMove Out
         events.clear();
-        events.push_back(QMouseEvent(QEvent::HoverMove, QPointF(20.0f, 40.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(20.0f, 40.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -931,8 +945,10 @@ private Q_SLOTS:
 
         // WHEN -> HoverMove In + Pressed other
         events.clear();
-        events.push_back(QMouseEvent(QEvent::HoverMove, QPointF(207.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
-        events.push_back(QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QEvent::HoverMove, QPointF(207.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -1001,8 +1017,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -1017,7 +1034,8 @@ private Q_SLOTS:
 
         // WHEN -> Move on same object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0f, 300.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -1032,7 +1050,8 @@ private Q_SLOTS:
 
         // WHEN -> Release on object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0f, 300.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -1049,8 +1068,10 @@ private Q_SLOTS:
 
         // WHEN -> Release outside of object
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0f, 0.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -1126,8 +1147,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -1141,7 +1163,8 @@ private Q_SLOTS:
 
         // WHEN -> Move on next object, show stay on previous picker unless all picks are requested
         events.clear();
-        events.push_back(QMouseEvent(QMouseEvent::MouseMove, QPointF(280.0f, 303.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseMove, QPointF(280.0f, 303.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         earlyReturn = !pickBVJob.runHelper();
 
@@ -1200,8 +1223,9 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        QList<QMouseEvent> events;
-        events.push_back(QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier));
+        QList<QPair<QObject *, QMouseEvent>> events;
+        events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0f, 300.0f),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
         pickBVJob.setMouseEvents(events);
         bool earlyReturn = !pickBVJob.runHelper();
 
@@ -1212,6 +1236,155 @@ private Q_SLOTS:
         Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
         QCOMPARE(change->propertyName(), "pressed");
     }
+
+    void checkPickerAndViewports()
+    {
+        // GIVEN
+        QmlSceneReader sceneReader(QUrl("qrc:/testscene_viewports.qml"));
+        QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root()));
+        QVERIFY(root);
+
+        QList<Qt3DRender::QRenderSettings *> renderSettings = root->findChildren<Qt3DRender::QRenderSettings *>();
+        QCOMPARE(renderSettings.size(), 1);
+        Qt3DRender::QPickingSettings *settings = renderSettings.first()->pickingSettings();
+
+        settings->setPickMethod(Qt3DRender::QPickingSettings::TrianglePicking);
+        settings->setPickResultMode(Qt3DRender::QPickingSettings::NearestPick);
+        settings->setFaceOrientationPickingMode(Qt3DRender::QPickingSettings::FrontFace);
+
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
+        TestArbiter arbiter;
+
+        // Runs Required jobs
+        runRequiredJobs(test.data());
+
+        // THEN
+        // object partially obscured by another viewport, make sure only visible portion is pickable
+        QList<Qt3DRender::QObjectPicker *> pickers = root->findChildren<Qt3DRender::QObjectPicker *>();
+        QCOMPARE(pickers.size(), 2);
+
+        Qt3DRender::QObjectPicker *picker = pickers.last();
+        QCOMPARE(picker->objectName(), QLatin1String("Picker2"));
+
+        Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
+        QVERIFY(backendPicker);
+        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
+
+        // 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),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        pickBVJob.setMouseEvents(events);
+        bool earlyReturn = !pickBVJob.runHelper();
+
+        // 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");
+
+        // 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),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        pickBVJob.setMouseEvents(events);
+        earlyReturn = !pickBVJob.runHelper();
+
+        // THEN -> Nothing happened
+        QVERIFY(!earlyReturn);
+        QVERIFY(!backendPicker->isPressed());
+        QCOMPARE(arbiter.events.count(), 0);
+    }
+
+    void checkMultipleRayDirections_data()
+    {
+        QTest::addColumn<QVector3D>("cameraOrigin");
+        QTest::addColumn<QVector3D>("cameraUpVector");
+
+        int k = 0;
+        const int n = 10;
+        for (int j=0; j<n; j++) {
+            QMatrix4x4 m;
+            m.rotate(360.f / (float)n * (float)j, 0.f, 0.f, 1.f);
+            for (int i=0; i<n; i++) {
+                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);
+                QTest::newRow(QString::number(k++).toLatin1().data()) << m * pos << m * up;
+            }
+        }
+    }
+
+    void checkMultipleRayDirections()
+    {
+        // GIVEN
+        QmlSceneReader sceneReader(QUrl("qrc:/testscene_cameraposition.qml"));
+        QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root()));
+        QVERIFY(root);
+
+        QList<Qt3DRender::QRenderSettings *> renderSettings = root->findChildren<Qt3DRender::QRenderSettings *>();
+        QCOMPARE(renderSettings.size(), 1);
+        Qt3DRender::QPickingSettings *settings = renderSettings.first()->pickingSettings();
+
+        settings->setPickMethod(Qt3DRender::QPickingSettings::TrianglePicking);
+
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
+        TestArbiter arbiter;
+
+        QList<Qt3DRender::QCamera *> cameras = root->findChildren<Qt3DRender::QCamera *>();
+        QCOMPARE(cameras.size(), 1);
+        Qt3DRender::QCamera *camera = cameras.first();
+
+        QFETCH(QVector3D, cameraUpVector);
+        camera->setUpVector(cameraUpVector);
+
+        QFETCH(QVector3D, cameraOrigin);
+        camera->setPosition(cameraOrigin);
+
+        // Runs Required jobs
+        runRequiredJobs(test.data());
+
+        // THEN
+        QList<Qt3DRender::QObjectPicker *> pickers = root->findChildren<Qt3DRender::QObjectPicker *>();
+        QCOMPARE(pickers.size(), 1);
+
+        Qt3DRender::QObjectPicker *picker = pickers.front();
+
+        Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
+        QVERIFY(backendPicker);
+        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
+
+        // 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),
+                                               Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+        pickBVJob.setMouseEvents(events);
+        bool earlyReturn = !pickBVJob.runHelper();
+
+        // THEN -> Pressed
+        QVERIFY(!earlyReturn);
+        QVERIFY(backendPicker->isPressed());
+        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+        QCOMPARE(change->propertyName(), "pressed");
+        Qt3DRender::QPickEventPtr pickEvent = change->value().value<Qt3DRender::QPickEventPtr>();
+        QVERIFY(pickEvent);
+
+        arbiter.events.clear();
+    }
+
 };
 
 QTEST_MAIN(tst_PickBoundingVolumeJob)
diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp
index 82a6d8b89..b630c447a 100644
--- a/tests/auto/render/qcamera/tst_qcamera.cpp
+++ b/tests/auto/render/qcamera/tst_qcamera.cpp
@@ -165,7 +165,7 @@ private Q_SLOTS:
         Qt3DRender::Render::Entity *cameraEntity = test->nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Qt3DRender::Render::EntityManager>(camera->id());
 
         // THEN
-        QVERIFY(qFuzzyCompare(*cameraEntity->worldTransform(), parentTransform->matrix()));
+        QVERIFY(qFuzzyCompare(convertToQMatrix4x4(*cameraEntity->worldTransform()), convertToQMatrix4x4(parentTransform->matrix())));
     }
 
     void checkTransformWithParentAndLookAt()
@@ -193,7 +193,7 @@ private Q_SLOTS:
         m.translate(0.f, 1.f, 0.f); // 90 deg z-rotation + x-translation = y-translation
         m.rotate(90.f, QVector3D(0.f, 0.f, 1.f));
 
-        const QMatrix4x4 worldTransform = *cameraEntity->worldTransform();
+        const QMatrix4x4 worldTransform = convertToQMatrix4x4(*cameraEntity->worldTransform());
         fuzzyCompareMatrix(worldTransform, m);
 
     }
@@ -234,7 +234,7 @@ private Q_SLOTS:
         m.translate(3.f, 2.f, -1.f); // child's world translation
         m.rotate(90.f, QVector3D(0.f, 1.f, 0.f)); // camera's rotation
 
-        fuzzyCompareMatrix(*childEntity->worldTransform(), m);
+        fuzzyCompareMatrix(convertToQMatrix4x4(*childEntity->worldTransform()), m);
     }
 };
 
diff --git a/tests/auto/render/qray3d/tst_qray3d.cpp b/tests/auto/render/qray3d/tst_qray3d.cpp
index e6ab02af0..e9d4d3033 100644
--- a/tests/auto/render/qray3d/tst_qray3d.cpp
+++ b/tests/auto/render/qray3d/tst_qray3d.cpp
@@ -70,7 +70,7 @@ static inline bool fuzzyCompare(float p1, float p2)
     return (qAbs(p1 - p2) <= (qIsNull(fac) ? 0.00001f : 0.00001f * fac));
 }
 
-static inline bool fuzzyCompare(const QVector3D &lhs, const QVector3D &rhs)
+static inline bool fuzzyCompare(const Vector3D &lhs, const Vector3D &rhs)
 {
     if (fuzzyCompare(lhs.x(), rhs.x()) &&
             fuzzyCompare(lhs.y(), rhs.y()) &&
@@ -85,59 +85,59 @@ static inline bool fuzzyCompare(const QVector3D &lhs, const QVector3D &rhs)
 
 void tst_QRay3D::create_data()
 {
-    QTest::addColumn<QVector3D>("point");
-    QTest::addColumn<QVector3D>("direction");
+    QTest::addColumn<Vector3D>("point");
+    QTest::addColumn<Vector3D>("direction");
 
     // normalized direction vectors
     QTest::newRow("line on x-axis from origin")
-            << QVector3D()
-            << QVector3D(1.0f, 0.0f, 0.0f);
+            << Vector3D()
+            << Vector3D(1.0f, 0.0f, 0.0f);
 
     QTest::newRow("line parallel -z-axis from 3,3,3")
-            << QVector3D(3.0f, 3.0f, 3.0f)
-            << QVector3D(0.0f, 0.0f, -1.0f);
+            << Vector3D(3.0f, 3.0f, 3.0f)
+            << Vector3D(0.0f, 0.0f, -1.0f);
 
     QTest::newRow("vertical line (parallel to y-axis)")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(0.0f, 1.0f, 0.0f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(0.0f, 1.0f, 0.0f);
 
     QTest::newRow("equidistant from all 3 axes")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(0.57735026919f, 0.57735026919f, 0.57735026919f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(0.57735026919f, 0.57735026919f, 0.57735026919f);
 
     // non-normalized direction vectors
     QTest::newRow("line on x-axis from origin - B")
-            << QVector3D()
-            << QVector3D(2.0f, 0.0f, 0.0f);
+            << Vector3D()
+            << Vector3D(2.0f, 0.0f, 0.0f);
 
     QTest::newRow("line parallel -z-axis from 3,3,3 - B")
-            << QVector3D(3.0f, 3.0f, 3.0f)
-            << QVector3D(0.0f, 0.0f, -0.7f);
+            << Vector3D(3.0f, 3.0f, 3.0f)
+            << Vector3D(0.0f, 0.0f, -0.7f);
 
     QTest::newRow("vertical line (parallel to y-axis) - B")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(0.0f, 5.3f, 0.0f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(0.0f, 5.3f, 0.0f);
 
     QTest::newRow("equidistant from all 3 axes - B")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(1.0f, 1.0f, 1.0f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(1.0f, 1.0f, 1.0f);
 
     QTest::newRow("negative direction")
-            << QVector3D(-3.0f, -3.0f, -3.0f)
-            << QVector3D(-1.2f, -1.8f, -2.4f);
+            << Vector3D(-3.0f, -3.0f, -3.0f)
+            << Vector3D(-1.2f, -1.8f, -2.4f);
 }
 
 void tst_QRay3D::create()
 {
-    QFETCH(QVector3D, point);
-    QFETCH(QVector3D, direction);
+    QFETCH(Vector3D, point);
+    QFETCH(Vector3D, direction);
     Qt3DRender::RayCasting::QRay3D ray(point, direction);
     QVERIFY(fuzzyCompare(ray.direction(), direction));
     QVERIFY(fuzzyCompare(ray.origin(), point));
 
     Qt3DRender::RayCasting::QRay3D ray2;
-    QCOMPARE(ray2.origin(), QVector3D(0, 0, 0));
-    QCOMPARE(ray2.direction(), QVector3D(0, 0, 1));
+    QCOMPARE(ray2.origin(), Vector3D(0, 0, 0));
+    QCOMPARE(ray2.direction(), Vector3D(0, 0, 1));
     ray2.setOrigin(point);
     ray2.setDirection(direction);
     QVERIFY(fuzzyCompare(ray.direction(), direction));
@@ -146,97 +146,97 @@ void tst_QRay3D::create()
 
 void tst_QRay3D::projection_data()
 {
-    QTest::addColumn<QVector3D>("point");
-    QTest::addColumn<QVector3D>("direction");
-    QTest::addColumn<QVector3D>("vector");
-    QTest::addColumn<QVector3D>("expected");
+    QTest::addColumn<Vector3D>("point");
+    QTest::addColumn<Vector3D>("direction");
+    QTest::addColumn<Vector3D>("vector");
+    QTest::addColumn<Vector3D>("expected");
 
     QTest::newRow("line on x-axis from origin")
-            << QVector3D()
-            << QVector3D(2.0f, 0.0f, 0.0f)
-            << QVector3D(0.6f, 0.0f, 0.0f)
-            << QVector3D(0.6f, 0.0f, 0.0f);
+            << Vector3D()
+            << Vector3D(2.0f, 0.0f, 0.0f)
+            << Vector3D(0.6f, 0.0f, 0.0f)
+            << Vector3D(0.6f, 0.0f, 0.0f);
 
     QTest::newRow("line parallel -z-axis from 3,3,3")
-            << QVector3D(3.0f, 3.0f, 3.0f)
-            << QVector3D(0.0f, 0.0f, -0.7f)
-            << QVector3D(3.0f, 3.0f, 2.4f)
-            << QVector3D(0.0f, 0.0f, 2.4f);
+            << Vector3D(3.0f, 3.0f, 3.0f)
+            << Vector3D(0.0f, 0.0f, -0.7f)
+            << Vector3D(3.0f, 3.0f, 2.4f)
+            << Vector3D(0.0f, 0.0f, 2.4f);
 
     QTest::newRow("vertical line (parallel to y-axis)")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(0.0f, 5.3f, 0.0f)
-            << QVector3D(0.5f, 0.6f, 0.5f)
-            << QVector3D(0.0f, 0.6f, 0.0f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(0.0f, 5.3f, 0.0f)
+            << Vector3D(0.5f, 0.6f, 0.5f)
+            << Vector3D(0.0f, 0.6f, 0.0f);
 
     QTest::newRow("equidistant from all 3 axes, project y-axis (with some z & x)")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(1.0f, 1.0f, 1.0f)
-            << QVector3D(0.5f, 5.0f, 0.5f)
-            << QVector3D(2.0f, 2.0f, 2.0f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(1.0f, 1.0f, 1.0f)
+            << Vector3D(0.5f, 5.0f, 0.5f)
+            << Vector3D(2.0f, 2.0f, 2.0f);
 
     QTest::newRow("negative direction line, project +ve y-axis (with some z & x)")
-            << QVector3D(-3.0f, -3.0f, -3.0f)
-            << QVector3D(-1.2f, -1.8f, -2.4f)
-            << QVector3D(0.5f, 5.0f, 0.5f)
-            << QVector3D(1.241379261016846f, 1.862068772315979f, 2.48275852203369f);
+            << Vector3D(-3.0f, -3.0f, -3.0f)
+            << Vector3D(-1.2f, -1.8f, -2.4f)
+            << Vector3D(0.5f, 5.0f, 0.5f)
+            << Vector3D(1.241379261016846f, 1.862068772315979f, 2.48275852203369f);
 }
 
 void tst_QRay3D::projection()
 {
-    QFETCH(QVector3D, point);
-    QFETCH(QVector3D, direction);
-    QFETCH(QVector3D, vector);
-    QFETCH(QVector3D, expected);
+    QFETCH(Vector3D, point);
+    QFETCH(Vector3D, direction);
+    QFETCH(Vector3D, vector);
+    QFETCH(Vector3D, expected);
     Qt3DRender::RayCasting::QRay3D line(point, direction);
-    QVector3D result = line.project(vector);
+    Vector3D result = line.project(vector);
     QVERIFY(fuzzyCompare(result, expected));
 }
 
 void tst_QRay3D::point_data()
 {
-    QTest::addColumn<QVector3D>("point");
-    QTest::addColumn<QVector3D>("direction");
-    QTest::addColumn<QVector3D>("point_on_line_pos_0_6");
-    QTest::addColumn<QVector3D>("point_on_line_neg_7_2");
+    QTest::addColumn<Vector3D>("point");
+    QTest::addColumn<Vector3D>("direction");
+    QTest::addColumn<Vector3D>("point_on_line_pos_0_6");
+    QTest::addColumn<Vector3D>("point_on_line_neg_7_2");
 
     QTest::newRow("line on x-axis from origin")
-            << QVector3D()
-            << QVector3D(2.0f, 0.0f, 0.0f)
-            << QVector3D(1.2f, 0.0f, 0.0f)
-            << QVector3D(-14.4f, 0.0f, 0.0f);
+            << Vector3D()
+            << Vector3D(2.0f, 0.0f, 0.0f)
+            << Vector3D(1.2f, 0.0f, 0.0f)
+            << Vector3D(-14.4f, 0.0f, 0.0f);
 
     QTest::newRow("line parallel -z-axis from 3,3,3")
-            << QVector3D(3.0f, 3.0f, 3.0f)
-            << QVector3D(0.0f, 0.0f, -0.7f)
-            << QVector3D(3.0f, 3.0f, 2.58f)
-            << QVector3D(3.0f, 3.0f, 8.04f);
+            << Vector3D(3.0f, 3.0f, 3.0f)
+            << Vector3D(0.0f, 0.0f, -0.7f)
+            << Vector3D(3.0f, 3.0f, 2.58f)
+            << Vector3D(3.0f, 3.0f, 8.04f);
 
     QTest::newRow("vertical line (parallel to y-axis)")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(0.0f, 5.3f, 0.0f)
-            << QVector3D(0.5f, 3.18f, 0.5f)
-            << QVector3D(0.5f, -38.16f, 0.5f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(0.0f, 5.3f, 0.0f)
+            << Vector3D(0.5f, 3.18f, 0.5f)
+            << Vector3D(0.5f, -38.16f, 0.5f);
 
     QTest::newRow("equidistant from all 3 axes")
-            << QVector3D(0.5f, 0.0f, 0.5f)
-            << QVector3D(1.0f, 1.0f, 1.0f)
-            << QVector3D(1.1f, 0.6f, 1.1f)
-            << QVector3D(-6.7f, -7.2f, -6.7f);
+            << Vector3D(0.5f, 0.0f, 0.5f)
+            << Vector3D(1.0f, 1.0f, 1.0f)
+            << Vector3D(1.1f, 0.6f, 1.1f)
+            << Vector3D(-6.7f, -7.2f, -6.7f);
 
     QTest::newRow("negative direction")
-            << QVector3D(-3.0f, -3.0f, -3.0f)
-            << QVector3D(-1.2f, -1.8f, -2.4f)
-            << QVector3D(-3.72f, -4.08f, -4.44f)
-            << QVector3D(5.64f, 9.96f, 14.28f);
+            << Vector3D(-3.0f, -3.0f, -3.0f)
+            << Vector3D(-1.2f, -1.8f, -2.4f)
+            << Vector3D(-3.72f, -4.08f, -4.44f)
+            << Vector3D(5.64f, 9.96f, 14.28f);
 }
 
 void tst_QRay3D::point()
 {
-    QFETCH(QVector3D, point);
-    QFETCH(QVector3D, direction);
-    QFETCH(QVector3D, point_on_line_pos_0_6);
-    QFETCH(QVector3D, point_on_line_neg_7_2);
+    QFETCH(Vector3D, point);
+    QFETCH(Vector3D, direction);
+    QFETCH(Vector3D, point_on_line_pos_0_6);
+    QFETCH(Vector3D, point_on_line_neg_7_2);
     Qt3DRender::RayCasting::QRay3D line(point, direction);
     QVERIFY(fuzzyCompare(line.point(0.6f), point_on_line_pos_0_6));
     QVERIFY(fuzzyCompare(line.point(-7.2f), point_on_line_neg_7_2));
@@ -246,39 +246,39 @@ void tst_QRay3D::point()
 
 void tst_QRay3D::contains_point_data()
 {
-    QTest::addColumn<QVector3D>("origin");
-    QTest::addColumn<QVector3D>("direction");
-    QTest::addColumn<QVector3D>("point");
+    QTest::addColumn<Vector3D>("origin");
+    QTest::addColumn<Vector3D>("direction");
+    QTest::addColumn<Vector3D>("point");
     QTest::addColumn<bool>("contains");
 
     QTest::newRow("bogus this line with null direction")
-            << QVector3D(1.0, 3.0, 3.0)
-            << QVector3D(0.0, 0.0, 0.0)
-            << QVector3D(1.0, 2.0, 4.0)
+            << Vector3D(1.0, 3.0, 3.0)
+            << Vector3D(0.0, 0.0, 0.0)
+            << Vector3D(1.0, 2.0, 4.0)
             << false;
 
     QTest::newRow("point at the origin")
-            << QVector3D(0.0, 0.0, 0.0)
-            << QVector3D(1.0, 3.0, 3.0)
-            << QVector3D(0.0, 0.0, 0.0)
+            << Vector3D(0.0, 0.0, 0.0)
+            << Vector3D(1.0, 3.0, 3.0)
+            << Vector3D(0.0, 0.0, 0.0)
             << true;
 
     QTest::newRow("close to the origin")
-            << QVector3D(1.0, 1.0, 1.0)
-            << QVector3D(1.0, 3.0, 3.0)
-            << QVector3D(1.0005f, 1.0005f, 1.0)
+            << Vector3D(1.0, 1.0, 1.0)
+            << Vector3D(1.0, 3.0, 3.0)
+            << Vector3D(1.0005f, 1.0005f, 1.0)
             << false;
 
     QTest::newRow("45 line line in plane x=1")
-            << QVector3D(1.0, 3.0, 3.0)
-            << QVector3D(0.0, -1.0, -1.0)
-            << QVector3D(1.0, 4.0, 4.0)
+            << Vector3D(1.0, 3.0, 3.0)
+            << Vector3D(0.0, -1.0, -1.0)
+            << Vector3D(1.0, 4.0, 4.0)
             << true;
     {
         // This is to prove that the constructed approach give the
         // same results
-        QVector3D p(1.0, 3.0, 3.0);
-        QVector3D v(0.0, -1.0, -1.0);
+        Vector3D p(1.0, 3.0, 3.0);
+        Vector3D v(0.0, -1.0, -1.0);
 
         QTest::newRow("constructed 45 line line in plane x=1")
                 << p
@@ -288,20 +288,20 @@ void tst_QRay3D::contains_point_data()
     }
 
     QTest::newRow("intersection with negative s in plane z=-1")
-        << QVector3D(1.0f, 2.0f, -1.0f)
-        << QVector3D(1.0f, 1.0f, 0.0f)
-        << QVector3D(2.0f, 1.0f, 0.0f)
+        << Vector3D(1.0f, 2.0f, -1.0f)
+        << Vector3D(1.0f, 1.0f, 0.0f)
+        << Vector3D(2.0f, 1.0f, 0.0f)
         << false;
 
     QTest::newRow("45 angled line")
-        << QVector3D(3.0f, 0.0f, -1.0f)
-        << QVector3D(1.0f, -1.0f, 1.0f)
-        << QVector3D(6.0f, -3.0f, 2.0f)
+        << Vector3D(3.0f, 0.0f, -1.0f)
+        << Vector3D(1.0f, -1.0f, 1.0f)
+        << Vector3D(6.0f, -3.0f, 2.0f)
         << true;
 
     {
-        QVector3D p(-10.0, 3.0, 3.0);
-        QVector3D v(0.0, 20.0, -1.0);
+        Vector3D p(-10.0, 3.0, 3.0);
+        Vector3D v(0.0, 20.0, -1.0);
         QTest::newRow("constructed vector close to axis")
                 << p
                 << v
@@ -310,8 +310,8 @@ void tst_QRay3D::contains_point_data()
     }
 
     {
-        QVector3D p(1.0, 3.0, 3.0);
-        QVector3D v(40.0, 500.0, -1.0);
+        Vector3D p(1.0, 3.0, 3.0);
+        Vector3D v(40.0, 500.0, -1.0);
         QTest::newRow("constructed larger values close to axis")
                 << p
                 << v
@@ -322,9 +322,9 @@ void tst_QRay3D::contains_point_data()
 
 void tst_QRay3D::contains_point()
 {
-    QFETCH(QVector3D, origin);
-    QFETCH(QVector3D, direction);
-    QFETCH(QVector3D, point);
+    QFETCH(Vector3D, origin);
+    QFETCH(Vector3D, direction);
+    QFETCH(Vector3D, point);
     QFETCH(bool, contains);
 
     Qt3DRender::RayCasting::QRay3D line(origin, direction);
@@ -338,9 +338,9 @@ void tst_QRay3D::contains_ray_data()
 
 void tst_QRay3D::contains_ray()
 {
-    QFETCH(QVector3D, origin);
-    QFETCH(QVector3D, direction);
-    QFETCH(QVector3D, point);
+    QFETCH(Vector3D, origin);
+    QFETCH(Vector3D, direction);
+    QFETCH(Vector3D, point);
     QFETCH(bool, contains);
 
     Qt3DRender::RayCasting::QRay3D line(origin, direction);
@@ -355,7 +355,7 @@ void tst_QRay3D::contains_ray()
         QVERIFY(line2.contains(line));
 
         // Different direction.
-        Qt3DRender::RayCasting::QRay3D line4(point, QVector3D(direction.y(), direction.x(), direction.z()));
+        Qt3DRender::RayCasting::QRay3D line4(point, Vector3D(direction.y(), direction.x(), direction.z()));
         QVERIFY(!line.contains(line4));
         QVERIFY(!line4.contains(line));
     } else {
@@ -367,41 +367,41 @@ void tst_QRay3D::contains_ray()
 
 void tst_QRay3D::distance_data()
 {
-    QTest::addColumn<QVector3D>("origin");
-    QTest::addColumn<QVector3D>("direction");
-    QTest::addColumn<QVector3D>("point");
+    QTest::addColumn<Vector3D>("origin");
+    QTest::addColumn<Vector3D>("direction");
+    QTest::addColumn<Vector3D>("point");
     QTest::addColumn<float>("distance");
 
     QTest::newRow("axis-x")
-        << QVector3D(6.0f, 0.0f, 0.0f)
-        << QVector3D(1.0f, 0.0f, 0.0f)
-        << QVector3D(0.0f, 0.0f, 0.0f)
+        << Vector3D(6.0f, 0.0f, 0.0f)
+        << Vector3D(1.0f, 0.0f, 0.0f)
+        << Vector3D(0.0f, 0.0f, 0.0f)
         << 0.0f;
 
     QTest::newRow("axis-x to 1")
-        << QVector3D(6.0f, 0.0f, 0.0f)
-        << QVector3D(1.0f, 0.0f, 0.0f)
-        << QVector3D(0.0f, 1.0f, 0.0f)
+        << Vector3D(6.0f, 0.0f, 0.0f)
+        << Vector3D(1.0f, 0.0f, 0.0f)
+        << Vector3D(0.0f, 1.0f, 0.0f)
         << 1.0f;
 
     QTest::newRow("neg-axis-y")
-        << QVector3D(0.0f, 6.0f, 0.0f)
-        << QVector3D(0.0f, -1.5f, 0.0f)
-        << QVector3D(0.0f, 100.0f, 0.0f)
+        << Vector3D(0.0f, 6.0f, 0.0f)
+        << Vector3D(0.0f, -1.5f, 0.0f)
+        << Vector3D(0.0f, 100.0f, 0.0f)
         << 0.0f;
 
     QTest::newRow("neg-axis-y to 2")
-        << QVector3D(0.0f, 6.0f, 0.0f)
-        << QVector3D(0.0f, -1.5f, 0.0f)
-        << QVector3D(2.0f, 0.0f, 0.0f)
+        << Vector3D(0.0f, 6.0f, 0.0f)
+        << Vector3D(0.0f, -1.5f, 0.0f)
+        << Vector3D(2.0f, 0.0f, 0.0f)
         << 2.0f;
 }
 
 void tst_QRay3D::distance()
 {
-    QFETCH(QVector3D, origin);
-    QFETCH(QVector3D, direction);
-    QFETCH(QVector3D, point);
+    QFETCH(Vector3D, origin);
+    QFETCH(Vector3D, direction);
+    QFETCH(Vector3D, point);
     QFETCH(float, distance);
 
     Qt3DRender::RayCasting::QRay3D line(origin, direction);
@@ -410,9 +410,9 @@ void tst_QRay3D::distance()
 
 void tst_QRay3D::compare()
 {
-    Qt3DRender::RayCasting::QRay3D ray1(QVector3D(10, 20, 30), QVector3D(-3, -4, -5));
-    Qt3DRender::RayCasting::QRay3D ray2(QVector3D(10, 20, 30), QVector3D(1.5f, 2.0f, 2.5f));
-    Qt3DRender::RayCasting::QRay3D ray3(QVector3D(0, 20, 30), QVector3D(-3, -4, -5));
+    Qt3DRender::RayCasting::QRay3D ray1(Vector3D(10, 20, 30), Vector3D(-3, -4, -5));
+    Qt3DRender::RayCasting::QRay3D ray2(Vector3D(10, 20, 30), Vector3D(1.5f, 2.0f, 2.5f));
+    Qt3DRender::RayCasting::QRay3D ray3(Vector3D(0, 20, 30), Vector3D(-3, -4, -5));
     QVERIFY(ray1 == ray1);
     QVERIFY(!(ray1 != ray1));
     QVERIFY(qFuzzyCompare(ray1, ray1));
@@ -427,7 +427,7 @@ void tst_QRay3D::compare()
 void tst_QRay3D::dataStream()
 {
 #ifndef QT_NO_DATASTREAM
-    Qt3DRender::RayCasting::QRay3D ray(QVector3D(1.0f, 2.0f, 3.0f), QVector3D(4.0f, 5.0f, 6.0f));
+    Qt3DRender::RayCasting::QRay3D ray(Vector3D(1.0f, 2.0f, 3.0f), Vector3D(4.0f, 5.0f, 6.0f));
 
     QByteArray data;
     {
@@ -452,13 +452,17 @@ void tst_QRay3D::transform_data()
 
 void tst_QRay3D::transform()
 {
-    QFETCH(QVector3D, point);
-    QFETCH(QVector3D, direction);
+    QFETCH(Vector3D, point);
+    QFETCH(Vector3D, direction);
 
-    QMatrix4x4 m;
-    m.translate(-1.0f, 2.5f, 5.0f);
-    m.rotate(45.0f, 1.0f, 1.0f, 1.0f);
-    m.scale(23.5f);
+    Matrix4x4 m;
+    {
+        QMatrix4x4 c;
+        c.translate(-1.0f, 2.5f, 5.0f);
+        c.rotate(45.0f, 1.0f, 1.0f, 1.0f);
+        c.scale(23.5f);
+        m = Matrix4x4(c);
+    }
 
     Qt3DRender::RayCasting::QRay3D ray1(point, direction);
     Qt3DRender::RayCasting::QRay3D ray2(ray1);
@@ -495,19 +499,19 @@ void tst_QRay3D::properties()
 
     qRegisterMetaType<Qt3DRender::RayCasting::QRay3D>();
 
-    obj.setRay(Qt3DRender::RayCasting::QRay3D(QVector3D(1, 2, 3), QVector3D(4, 5, 6)));
+    obj.setRay(Qt3DRender::RayCasting::QRay3D(Vector3D(1, 2, 3), Vector3D(4, 5, 6)));
 
     Qt3DRender::RayCasting::QRay3D r = qvariant_cast<Qt3DRender::RayCasting::QRay3D>(obj.property("ray"));
-    QCOMPARE(r.origin(), QVector3D(1, 2, 3));
-    QCOMPARE(r.direction(), QVector3D(4, 5, 6));
+    QCOMPARE(r.origin(), Vector3D(1, 2, 3));
+    QCOMPARE(r.direction(), Vector3D(4, 5, 6));
 
     obj.setProperty("ray",
                     qVariantFromValue
-                        (Qt3DRender::RayCasting::QRay3D(QVector3D(-1, -2, -3), QVector3D(-4, -5, -6))));
+                        (Qt3DRender::RayCasting::QRay3D(Vector3D(-1, -2, -3), Vector3D(-4, -5, -6))));
 
     r = qvariant_cast<Qt3DRender::RayCasting::QRay3D>(obj.property("ray"));
-    QCOMPARE(r.origin(), QVector3D(-1, -2, -3));
-    QCOMPARE(r.direction(), QVector3D(-4, -5, -6));
+    QCOMPARE(r.origin(), Vector3D(-1, -2, -3));
+    QCOMPARE(r.direction(), Vector3D(-4, -5, -6));
 }
 
 void tst_QRay3D::metaTypes()
@@ -523,14 +527,14 @@ void tst_QRay3D::shouldNotAllowNullDirection()
     // GIVEN
     Qt3DRender::RayCasting::QRay3D ray;
 
-    QCOMPARE(ray.origin(), QVector3D(0, 0, 0));
-    QCOMPARE(ray.direction(), QVector3D(0, 0, 1));
+    QCOMPARE(ray.origin(), Vector3D(0, 0, 0));
+    QCOMPARE(ray.direction(), Vector3D(0, 0, 1));
 
     // WHEN
-    ray.setDirection(QVector3D(0, 0, 0));
+    ray.setDirection(Vector3D(0, 0, 0));
 
     // THEN
-    QCOMPARE(ray.direction(), QVector3D(0, 0, 1));
+    QCOMPARE(ray.direction(), Vector3D(0, 0, 1));
 }
 
 QTEST_APPLESS_MAIN(tst_QRay3D)
diff --git a/tests/auto/render/raycasting/tst_raycasting.cpp b/tests/auto/render/raycasting/tst_raycasting.cpp
index 0f3d04962..d14bcddcb 100644
--- a/tests/auto/render/raycasting/tst_raycasting.cpp
+++ b/tests/auto/render/raycasting/tst_raycasting.cpp
@@ -72,15 +72,15 @@ void tst_RayCasting::shouldIntersect_data()
     QTest::addColumn<Sphere>("sphere");
     QTest::addColumn<bool>("shouldIntersect");
 
-    QRay3D ray(QVector3D(1, 1, 1), QVector3D(0, 0, 1));
+    QRay3D ray(Vector3D(1, 1, 1), Vector3D(0, 0, 1));
 
-    Sphere sphere1(QVector3D(1, 1, 1), 2);
-    Sphere sphere2(QVector3D(0, 0, 0), 3);
-    Sphere sphere3(QVector3D(0, 1, 3), 1);
-    Sphere sphere4(QVector3D(4, 4, 5), 1);
-    Sphere sphere5(QVector3D(2, 2, 11), 5);
-    Sphere sphere6(QVector3D(2, 2, 13), 1);
-    Sphere sphere7(QVector3D(2, 2, 15), 5);
+    Sphere sphere1(Vector3D(1, 1, 1), 2);
+    Sphere sphere2(Vector3D(0, 0, 0), 3);
+    Sphere sphere3(Vector3D(0, 1, 3), 1);
+    Sphere sphere4(Vector3D(4, 4, 5), 1);
+    Sphere sphere5(Vector3D(2, 2, 11), 5);
+    Sphere sphere6(Vector3D(2, 2, 13), 1);
+    Sphere sphere7(Vector3D(2, 2, 15), 5);
 
     QTest::newRow("Ray starts inside sphere") << ray << sphere1 << true;
     QTest::newRow("Ray starts inside sphere") << ray << sphere2 << true;
@@ -97,7 +97,7 @@ void tst_RayCasting::shouldIntersect()
     QFETCH(Sphere, sphere);
     QFETCH(bool, shouldIntersect);
 
-    QVector3D intersectionPoint;
+    Vector3D intersectionPoint;
 
     QCOMPARE(sphere.intersects(ray, &intersectionPoint), shouldIntersect);
 }
@@ -206,16 +206,16 @@ void tst_RayCasting::shouldReturnHits_data()
     QTest::addColumn<QVector<QNodeId> >("hits");
     QTest::addColumn<QAbstractCollisionQueryService::QueryMode >("queryMode");
 
-    QRay3D ray(QVector3D(1, 1, 1), QVector3D(0, 0, 1));
+    QRay3D ray(Vector3D(1, 1, 1), Vector3D(0, 0, 1));
 
     this->boundingVolumes.clear();
-    this->boundingVolumes.append(QVector<Sphere>() << Sphere(QVector3D(1, 1, 1), 3, QNodeId::createId())
-                                 << Sphere(QVector3D(0, 0, 0), 3, QNodeId::createId())
-                                 << Sphere(QVector3D(0, 1, 3), 1, QNodeId::createId())
-                                 << Sphere(QVector3D(4, 4, 5), 1, QNodeId::createId())
-                                 << Sphere(QVector3D(2, 2, 11), 5, QNodeId::createId())
-                                 << Sphere(QVector3D(2, 2, 13), 1, QNodeId::createId())
-                                 << Sphere(QVector3D(2, 2, 15), 5, QNodeId::createId()));
+    this->boundingVolumes.append(QVector<Sphere>() << Sphere(Vector3D(1, 1, 1), 3, QNodeId::createId())
+                                 << Sphere(Vector3D(0, 0, 0), 3, QNodeId::createId())
+                                 << Sphere(Vector3D(0, 1, 3), 1, QNodeId::createId())
+                                 << Sphere(Vector3D(4, 4, 5), 1, QNodeId::createId())
+                                 << Sphere(Vector3D(2, 2, 11), 5, QNodeId::createId())
+                                 << Sphere(Vector3D(2, 2, 13), 1, QNodeId::createId())
+                                 << Sphere(Vector3D(2, 2, 15), 5, QNodeId::createId()));
 
     QTest::newRow("All hits, One sphere intersect") << ray
                                                     << (QVector<QBoundingVolume *> () << volumeAt(0) << volumeAt(3))
@@ -276,11 +276,11 @@ void tst_RayCasting::shouldReturnHits()
 void tst_RayCasting::shouldUseProvidedBoudingVolumes()
 {
     // GIVEN
-    QRay3D ray(QVector3D(1, 1, 1), QVector3D(0, 0, 1));
+    QRay3D ray(Vector3D(1, 1, 1), Vector3D(0, 0, 1));
 
-    Sphere sphere1(QVector3D(1, 1, 1), 3);
-    Sphere sphere3(QVector3D(0, 1, 3), 1);
-    Sphere sphere4(QVector3D(4, 4, 5), 1);
+    Sphere sphere1(Vector3D(1, 1, 1), 3);
+    Sphere sphere3(Vector3D(0, 1, 3), 1);
+    Sphere sphere4(Vector3D(4, 4, 5), 1);
 
     MyBoudingVolumesProvider provider(QVector<QBoundingVolume *>() << &sphere1 << &sphere4 << &sphere3);
     QVector<QNodeId> hits(QVector<QNodeId>() << sphere1.id() << sphere3.id());
@@ -325,10 +325,10 @@ void tst_RayCasting::mousePicking()
 
     // Window center on near plane
     QRay3D ray = Qt3DRender::Render::AbstractPickingJob::intersectionRay(viewport.center().toPoint(),
-                                                                            camera.viewMatrix(),
-                                                                            camera.projectionMatrix(),
-                                                                            viewport.toRect());
-    Qt3DRender::Render::Sphere s(QVector3D(0.0f, 0.5f, 0.0f), 1.0f);
+                                                                         Matrix4x4(camera.viewMatrix()),
+                                                                         Matrix4x4(camera.projectionMatrix()),
+                                                                         viewport.toRect());
+    Qt3DRender::Render::Sphere s(Vector3D(0.0f, 0.5f, 0.0f), 1.0f);
 
     // WHEN
     bool intersects = s.intersects(ray, nullptr);
@@ -338,9 +338,9 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::AbstractPickingJob::intersectionRay(viewport.topLeft().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
-                                                                     viewport.toRect());
+                                                                  Matrix4x4(camera.viewMatrix()),
+                                                                  Matrix4x4(camera.projectionMatrix()),
+                                                                  viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
     // THEN
@@ -348,9 +348,9 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::AbstractPickingJob::intersectionRay(viewport.topRight().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
-                                                                     viewport.toRect());
+                                                                  Matrix4x4(camera.viewMatrix()),
+                                                                  Matrix4x4(camera.projectionMatrix()),
+                                                                  viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
     // THEN
@@ -358,9 +358,9 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::AbstractPickingJob::intersectionRay(viewport.bottomLeft().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
-                                                                     viewport.toRect());
+                                                                  Matrix4x4(camera.viewMatrix()),
+                                                                  Matrix4x4(camera.projectionMatrix()),
+                                                                  viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
     // THEN
@@ -368,9 +368,9 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::AbstractPickingJob::intersectionRay(viewport.bottomRight().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
-                                                                     viewport.toRect());
+                                                                  Matrix4x4(camera.viewMatrix()),
+                                                                  Matrix4x4(camera.projectionMatrix()),
+                                                                  viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
     // THEN
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 2fcebaa3c..ef147ba7f 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -24,14 +24,12 @@ qtConfig(private_tests) {
         attribute \
         geometry \
         geometryrenderer \
-        raycasting \
         qcameraselector \
         qclearbuffers \
         qframegraphnode \
         qlayerfilter \
         qabstractlight \
         qenvironmentlight \
-        qray3d \
         qrenderpassfilter \
         qrenderstate \
         qrendertargetselector \
@@ -45,8 +43,6 @@ qtConfig(private_tests) {
         objectpicker \
 #        qboundingvolumedebug \
 #        boundingvolumedebug \
-        trianglesextractor \
-        triangleboundingvolume \
         ddstextures \
         shadercache \
         layerfiltering \
@@ -113,9 +109,20 @@ qtConfig(private_tests) {
         qraycaster \
         raycaster \
         raycastingjob \
-        qcamera
+        qcamera \
+        renderbarrierjob
 
     QT_FOR_CONFIG = 3dcore-private
+    # TO DO: These could be restored to be executed in all cases
+    # when aligned-malloc.pri becomes part of the test framework
+    !qtConfig(qt3d-simd-avx2): {
+      SUBDIRS += \
+        qray3d \
+        raycasting \
+        trianglesextractor \
+        triangleboundingvolume \
+    }
+
     qtConfig(qt3d-extras) {
         SUBDIRS += \
             qmaterial \
diff --git a/tests/auto/render/renderbarrierjob/renderbarrierjob.pro b/tests/auto/render/renderbarrierjob/renderbarrierjob.pro
new file mode 100644
index 000000000..5a988144f
--- /dev/null
+++ b/tests/auto/render/renderbarrierjob/renderbarrierjob.pro
@@ -0,0 +1,9 @@
+TEMPLATE = app
+
+TARGET = tst_renderbarrierjob
+
+QT += 3dcore 3dcore-private 3drender 3drender-private testlib
+
+CONFIG += testcase
+
+SOURCES += tst_renderbarrierjob.cpp
diff --git a/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp b/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp
new file mode 100644
index 000000000..e3b49edd4
--- /dev/null
+++ b/tests/auto/render/renderbarrierjob/tst_renderbarrierjob.cpp
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** 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/QtTest>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QThread>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
+#include <Qt3DRender/private/job_common_p.h>
+
+class TestRenderThread : public QThread
+{
+public:
+    TestRenderThread(Qt3DRender::Render::RenderBarrierJobPtr barrier)
+        : m_barrier(barrier)
+    {}
+
+    void run() override
+    {
+        m_started.store(1);
+        m_writeSemaphore.release();
+        m_readSemaphore.acquire();
+
+        m_barrier->allowToProceed();
+        m_released.store(1);
+        m_writeSemaphore.release();
+        m_readSemaphore.acquire();
+
+        m_barrier->waitForDependencies();
+        m_completed.store(1);
+    }
+
+    Qt3DRender::Render::RenderBarrierJobPtr m_barrier;
+    QSemaphore m_writeSemaphore;
+    QSemaphore m_readSemaphore;
+
+    QAtomicInt m_started;
+    QAtomicInt m_released;
+    QAtomicInt m_completed;
+};
+
+class tst_RenderBarrierJob : public QObject
+{
+    Q_OBJECT
+public :
+    tst_RenderBarrierJob() {}
+    ~tst_RenderBarrierJob() {}
+
+private Q_SLOTS:
+    void shouldControlRenderThread()
+    {
+        // GIVEN a barrier (of any type)
+        auto barrier = Qt3DRender::Render::RenderBarrierJobPtr::create(Qt3DRender::Render::JobTypes::BeginDrawingBarrier);
+        TestRenderThread testThread(barrier);
+
+        // THEN
+        QVERIFY(testThread.m_started.load() == 0);
+        QVERIFY(testThread.m_released.load() == 0);
+        QVERIFY(testThread.m_completed.load() == 0);
+
+        // WHEN
+        testThread.start();
+        testThread.m_writeSemaphore.acquire();
+
+        // THEN thread should have started
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 0);
+        QVERIFY(testThread.m_completed.load() == 0);
+        testThread.m_readSemaphore.release();
+
+        // WHEN
+        testThread.m_writeSemaphore.acquire();
+
+        // THEN job should be released
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 1);
+        QVERIFY(testThread.m_completed.load() == 0);
+        testThread.m_readSemaphore.release();
+
+        // WHEN job runs and we wait for thread
+        barrier->run();
+        testThread.wait();
+
+        // THEN thread should be finished
+        QVERIFY(testThread.m_started.load() == 1);
+        QVERIFY(testThread.m_released.load() == 1);
+        QVERIFY(testThread.m_completed.load() == 1);
+    }
+};
+
+QTEST_MAIN(tst_RenderBarrierJob)
+
+#include "tst_renderbarrierjob.moc"
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index cfccf8b78..b941a2ac4 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -34,6 +34,9 @@
 #include <Qt3DRender/private/viewportnode_p.h>
 #include <Qt3DRender/private/renderview_p.h>
 #include <Qt3DRender/private/renderviewbuilder_p.h>
+#include <Qt3DRender/private/offscreensurfacehelper_p.h>
+#include <Qt3DRender/private/loadtexturedatajob_p.h>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
 
 class tst_Renderer : public QObject
 {
@@ -63,47 +66,62 @@ private Q_SLOTS:
         // NOTE: FilterCompatibleTechniqueJob and ShaderGathererJob cannot run because the context
         // is not initialized in this test
 
-        const int singleRenderViewJobCount = 11 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+        const int renderBarrierJobCount = 5;
+        // Barriers:    readRenderQueueSize
+        //              beginDrawing
+        //              updateGLResources
+        //              prepareCommandSubmission
+        //              endDrawing
+
+        const int renderViewJobCount = 13 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
         // RenderViewBuilder renderViewJob,
         //                   renderableEntityFilterJob,
         //                   lightGatherJob,
         //                   computableEntityFilterJob,
         //                   syncRenderViewInitializationJob,
-        //                   syncFrustumCullingJob,
         //                   filterEntityByLayerJob,
+        //                   syncFilterEntityByLayerJob,
+        //                   syncFrustumCullingJob,
         //                   filterProximityJob,
         //                   setClearDrawBufferIndexJob,
         //                   frustumCullingJob,
         //                   syncRenderCommandBuldingJob,
-        //                   syncRenderViewCommandBuilderJob)
-        //                   n * (RenderViewCommandBuildJobs + MaterialGathererJobs
+        //                   syncRenderViewCommandBuilderJob
+        //                   n * RenderViewCommandBuildJobs
+
+        const int flagIndependentRendererJobCount = 6;
+        // Flag independent: updateLevelOfDetailJob
+        //                   cleanupJob
+        //                   sendRenderCaptureJob
+        //                   sendBufferCaptureJob
+        //                   VAOGatherer
+        //                   updateSkinningPaletteJob
+
+        const int flagIndependetRenderViewJobCount = renderViewJobCount - 2;
+        // Cached: filterEntityByLayerJob,
+        //         syncFilterEntityByLayerJob,
+
 
         // WHEN (nothing dirty, no buffers)
         QVector<Qt3DCore::QAspectJobPtr> jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
-                 singleRenderViewJobCount); // Only valid for the first call to renderBinJobs(), since subsequent calls won't have the renderqueue reset
-
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount);
 
         // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityEnabledDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // filterEntityByLayerJob
+                 1 + // syncFilterEntityByLayerJob
                  1); // EntityEnabledDirty
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -112,17 +130,14 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::TransformDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
-                 1 + // updateSkinningPaletteJob
                  1); // ExpandBoundingVolumeJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -131,16 +146,13 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::GeometryDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
-                 1 + // updateSkinningPaletteJob
                  1); // ExpandBoundingVolumeJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -149,14 +161,11 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::BuffersDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // updateSkinningPaletteJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
                  1); // BufferGathererJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
@@ -165,16 +174,26 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::TexturesDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // TexturesGathererJob
-                 1 + // updateSkinningPaletteJob
-                 1); // SyncTexturesGathererJob
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // LoadTextureDataJob
+                 1); // TexturesGathererJob
+
+        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+
+        // WHEN
+        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::SkeletonDataDirty, nullptr);
+        jobs = renderer.renderBinJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 flagIndependetRenderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1); // SyncSkeletonLoadingJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
@@ -182,28 +201,47 @@ private Q_SLOTS:
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
-        // THEN (level
+        // THEN
         QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendRenderCaptureJob
-                 1 + // sendBufferCaptureJob
-                 1 + // VAOGatherer
-                 1 + // EntityEnabledDirty
+                 renderViewJobCount +
+                 renderBarrierJobCount +
+                 flagIndependentRendererJobCount +
+                 1 + // UpdateTreeEnablee
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
-                 1 + // ExpandBoundingVolumeJob
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
+                 1 + // ExpandBoundingVolumeJob
                  1 + // BufferGathererJob
+                 1 + // LoadTextureDataJob
                  1 + // TexturesGathererJob
-                 1 + // updateSkinningPaletteJob
-                 1); // SyncTexturesGathererJob
+                 1 + // SyncSkeletonLoadingJob
+                 1 + // FilterCompatibleTechniqueJob
+                 1 + // ShaderGathererJob
+                 Qt3DRender::Render::RenderViewBuilder::optimalJobCount() + // MaterialGathererJobs
+                 1); // syncMaterialGathererJob
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+    }
+
+    void checkRenderBarrierJobDependencies()
+    {
+        // GIVEN
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+
+        // THEN
 
+        // internal dependencies
+        QVERIFY(renderer.beginDrawingBarrierJob()->dependencies().contains(renderer.readRenderQueueSizeBarrierJob()));
+        QVERIFY(renderer.updateGLResourcesBarrierJob()->dependencies().contains(renderer.beginDrawingBarrierJob()));
+        QVERIFY(renderer.prepareCommandSubmissionBarrierJob()->dependencies().contains(renderer.updateGLResourcesBarrierJob()));
+        QVERIFY(renderer.endDrawingBarrierJob()->dependencies().contains(renderer.prepareCommandSubmissionBarrierJob()));
 
+        QVERIFY(renderer.filterCompatibleTechniqueJob()->dependencies().contains(renderer.beginDrawingBarrierJob()));
+        QVERIFY(renderer.loadTextureJob()->dependencies().contains(renderer.updateGLResourcesBarrierJob()));
+        QVERIFY(renderer.prepareCommandSubmissionBarrierJob()->dependencies().contains(renderer.loadTextureJob()));
+        QVERIFY(renderer.updateGLResourcesBarrierJob()->dependencies().contains(renderer.filterCompatibleTechniqueJob()));
     }
 };
 
diff --git a/tests/auto/render/renderqueue/renderqueue.pro b/tests/auto/render/renderqueue/renderqueue.pro
index 92e675285..945fe4cf4 100644
--- a/tests/auto/render/renderqueue/renderqueue.pro
+++ b/tests/auto/render/renderqueue/renderqueue.pro
@@ -7,3 +7,5 @@ QT += 3dcore 3dcore-private 3drender 3drender-private testlib
 CONFIG += testcase
 
 SOURCES += tst_renderqueue.cpp
+
+include(../../core/common/common.pri)
diff --git a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
index d18b270c5..1bdf20170 100644
--- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -49,6 +49,7 @@
 #include <Qt3DRender/private/qrenderaspect_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
+#include <Qt3DRender/private/renderbarrierjob_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -306,21 +307,25 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
-            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 6);
+            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 7);
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.renderableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.computableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.lightGathererJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
+            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->updateGLResourcesBarrierJob()));
             for (const auto materialGatherer : renderViewBuilder.materialGathererJobs()) {
                 QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(materialGatherer));
             }
 
             // Step 5
             for (const auto renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
-                QCOMPARE(renderViewBuilderJob->dependencies().first().data(), renderViewBuilder.syncRenderCommandBuildingJob().data());
+                QCOMPARE(renderViewBuilderJob->dependencies().size(), 4);
+                QVERIFY(renderViewBuilderJob->dependencies().contains(renderViewBuilder.syncRenderCommandBuildingJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateSkinningPaletteJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateWorldBoundingVolumeJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
             }
 
             // Step 6
@@ -378,7 +383,7 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(renderViewBuilder.syncFrustumCullingJob()));
             QVERIFY(renderViewBuilder.frustumCullingJob()->dependencies().contains(testAspect.renderer()->expandBoundingVolumeJob()));
 
-            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 7);
+            QCOMPARE(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().size(), renderViewBuilder.materialGathererJobs().size() + 8);
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.syncRenderViewInitializationJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.renderableEntityFilterJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.computableEntityFilterJob()));
@@ -386,14 +391,18 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.lightGathererJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.frustumCullingJob()));
             QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(renderViewBuilder.filterProximityJob()));
+            QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(testAspect.renderer()->updateGLResourcesBarrierJob()));
             for (const auto materialGatherer : renderViewBuilder.materialGathererJobs()) {
                 QVERIFY(renderViewBuilder.syncRenderCommandBuildingJob()->dependencies().contains(materialGatherer));
             }
 
             // Step 5
             for (const auto renderViewBuilderJob : renderViewBuilder.renderViewBuilderJobs()) {
-                QCOMPARE(renderViewBuilderJob->dependencies().size(), 1);
-                QCOMPARE(renderViewBuilderJob->dependencies().first().data(), renderViewBuilder.syncRenderCommandBuildingJob().data());
+                QCOMPARE(renderViewBuilderJob->dependencies().size(), 4);
+                QVERIFY(renderViewBuilderJob->dependencies().contains(renderViewBuilder.syncRenderCommandBuildingJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateSkinningPaletteJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateWorldBoundingVolumeJob()));
+                QVERIFY(renderViewBuilderJob->dependencies().contains(testAspect.renderer()->updateShaderDataTransformJob()));
             }
 
             // Step 6
@@ -562,14 +571,14 @@ private Q_SLOTS:
         renderViewBuilder.buildJobHierachy();
 
         // THEN
-        QCOMPARE(renderViewBuilder.frustumCullingJob()->viewProjection(), QMatrix4x4());
+        QCOMPARE(renderViewBuilder.frustumCullingJob()->viewProjection(), Matrix4x4());
 
         // WHEN
         renderViewBuilder.renderViewJob()->run();
         renderViewBuilder.syncFrustumCullingJob()->run();
 
         // THEN
-        QCOMPARE(renderViewBuilder.frustumCullingJob()->viewProjection(), camera->projectionMatrix() * camera->viewMatrix());
+        QCOMPARE(convertToQMatrix4x4(renderViewBuilder.frustumCullingJob()->viewProjection()), camera->projectionMatrix() * camera->viewMatrix());
     }
 
     void checkRemoveEntitiesNotInSubset()
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index d941126e2..8ff1a584a 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -59,23 +59,6 @@ private Q_SLOTS:
 
     }
 
-    void checkRenderViewDoesNotLeak()
-    {
-        QSKIP("Allocated Disabled");
-        // GIVEN
-        Qt3DCore::QFrameAllocator allocator(192, 16, 128);
-        RenderView *rv = allocator.allocate<RenderView>();
-
-        // THEN
-        QVERIFY(!allocator.isEmpty());
-
-        // WHEN
-        delete rv;
-
-        // THEN
-        QVERIFY(allocator.isEmpty());
-    }
-
     void checkRenderViewInitialState()
     {
         // GIVEN
diff --git a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
index 81d0ee4a2..247c5e0a3 100644
--- a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
@@ -711,17 +711,25 @@ void tst_RenderViewUtils::transformedProperties()
     QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
 
     // WHEN
-    const QVector3D position = QVector3D(15.0f, -5.0f, 10.0f);
-    QMatrix4x4 worldMatrix;
-    QMatrix4x4 viewMatrix;
-
-    worldMatrix.translate(-3.0f, 2.0f, 7.5f);
-    viewMatrix.translate(9.0f, 6.0f, 12.0f);
+    const Vector3D position = Vector3D(15.0f, -5.0f, 10.0f);
+    const QVector3D positionQt = convertToQVector3D(position);
+    Matrix4x4 worldMatrix;
+    {
+        QMatrix4x4 m;
+        m.translate(-3.0f, 2.0f, 7.5f);
+        worldMatrix = Matrix4x4(m);
+    }
+    Matrix4x4 viewMatrix;
+    {
+        QMatrix4x4 m;
+        m.translate(9.0f, 6.0f, 12.0f);
+        viewMatrix = Matrix4x4(m);
+    }
 
-    shaderData->setProperty("position0", position);
-    shaderData->setProperty("position1", position);
-    shaderData->setProperty("position2", position);
-    shaderData->setProperty("position3", position);
+    shaderData->setProperty("position0", positionQt);
+    shaderData->setProperty("position1", positionQt);
+    shaderData->setProperty("position2", positionQt);
+    shaderData->setProperty("position3", positionQt);
     shaderData->setProperty("position1Transformed", Qt3DRender::Render::ShaderData::ModelToEye);
     shaderData->setProperty("position2Transformed", Qt3DRender::Render::ShaderData::ModelToWorld);
     shaderData->setProperty("position3Transformed", Qt3DRender::Render::ShaderData::ModelToWorldDirection);
@@ -737,16 +745,16 @@ void tst_RenderViewUtils::transformedProperties()
 
     // WHEN
     backendShaderData->updateWorldTransform(worldMatrix);
-    const QVector3D position1Value = backendShaderData->getTransformedProperty(QStringLiteral("position1"), viewMatrix).value<QVector3D>();
-    const QVector3D position2Value = backendShaderData->getTransformedProperty(QStringLiteral("position2"), viewMatrix).value<QVector3D>();
-    const QVector3D position3Value = backendShaderData->getTransformedProperty(QStringLiteral("position3"), viewMatrix).value<QVector3D>();
+    const Vector3D position1Value = backendShaderData->getTransformedProperty(QStringLiteral("position1"), viewMatrix).value<Vector3D>();
+    const Vector3D position2Value = backendShaderData->getTransformedProperty(QStringLiteral("position2"), viewMatrix).value<Vector3D>();
+    const Vector3D position3Value = backendShaderData->getTransformedProperty(QStringLiteral("position3"), viewMatrix).value<Vector3D>();
     const QVariant position0Value = backendShaderData->getTransformedProperty(QStringLiteral("position0"), viewMatrix);
 
     // THEN
     QCOMPARE(position0Value, QVariant());
     QCOMPARE(position1Value, viewMatrix * worldMatrix * position);
     QCOMPARE(position2Value, worldMatrix * position);
-    QCOMPARE(position3Value, (worldMatrix * QVector4D(position, 0.0f)).toVector3D());
+    QCOMPARE(position3Value, Vector3D((worldMatrix * Vector4D(position, 0.0f))));
 }
 
 void tst_RenderViewUtils::shouldNotifyDynamicPropertyChanges()
diff --git a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
index 2c3f3f7c9..da420e1ac 100644
--- a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
+++ b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
@@ -49,7 +49,7 @@ public:
 
     }
 
-    virtual void visit(uint andx, const QVector3D &a, uint bndx, const QVector3D &b)
+    virtual void visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b)
     {
         m_segments.push_back(TestSegment(andx, a, bndx, b));
     }
@@ -69,7 +69,7 @@ public:
         return m_segments.size();
     }
 
-    bool verifySegment(uint segment, uint andx, uint bndx, QVector3D a, QVector3D b) const
+    bool verifySegment(uint segment, uint andx, uint bndx, Vector3D a, Vector3D b) const
     {
         if (segment >= uint(m_segments.size()))
             return false;
@@ -87,13 +87,13 @@ private:
     struct TestSegment
     {
         uint abcndx[2];
-        QVector3D abc[2];
+        Vector3D abc[2];
         TestSegment()
         {
             abcndx[0] = abcndx[1] = uint(-1);
         }
 
-        TestSegment(uint andx, const QVector3D &a, uint bndx, const QVector3D &b)
+        TestSegment(uint andx, const Vector3D &a, uint bndx, const Vector3D &b)
         {
             abcndx[0] = andx;
             abcndx[1] = bndx;
@@ -218,9 +218,9 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(3));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,1), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 2,3, QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifySegment(2, 4,5, QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,1), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 2,3, Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifySegment(2, 4,5, Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 
     void testVisitSegmentsIndexed()
@@ -318,11 +318,11 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(5));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 1,2, QVector3D(1,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(2, 2,3, QVector3D(1,1,0), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifySegment(3, 0,2, QVector3D(0,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(4, 1,3, QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 1,2, Vector3D(1,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(2, 2,3, Vector3D(1,1,0), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(3, 0,2, Vector3D(0,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(4, 1,3, Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 
     void testVisitLineStrip()
@@ -387,9 +387,9 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(3));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 1,2, QVector3D(1,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(2, 2,3, QVector3D(1,1,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 1,2, Vector3D(1,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(2, 2,3, Vector3D(1,1,0), Vector3D(0,1,0)));
     }
 
     void testVisitListStripIndexed()
@@ -481,9 +481,9 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(3));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 1,2, QVector3D(1,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(2, 2,3, QVector3D(1,1,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 1,2, Vector3D(1,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(2, 2,3, Vector3D(1,1,0), Vector3D(0,1,0)));
     }
 
     void testVisitLineLoop()
@@ -548,10 +548,10 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(4));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 1,2, QVector3D(1,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(2, 2,3, QVector3D(1,1,0), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifySegment(3, 3,0, QVector3D(0,1,0), QVector3D(0,0,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 1,2, Vector3D(1,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(2, 2,3, Vector3D(1,1,0), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(3, 3,0, Vector3D(0,1,0), Vector3D(0,0,0)));
     }
 
     void testVisitLineLoopIndexed()
@@ -643,10 +643,10 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(4));
-        QVERIFY(visitor.verifySegment(0, 0,1, QVector3D(0,0,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifySegment(1, 1,2, QVector3D(1,0,0), QVector3D(1,1,0)));
-        QVERIFY(visitor.verifySegment(2, 2,3, QVector3D(1,1,0), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifySegment(3, 3,0, QVector3D(0,1,0), QVector3D(0,0,0)));
+        QVERIFY(visitor.verifySegment(0, 0,1, Vector3D(0,0,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifySegment(1, 1,2, Vector3D(1,0,0), Vector3D(1,1,0)));
+        QVERIFY(visitor.verifySegment(2, 2,3, Vector3D(1,1,0), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(3, 3,0, Vector3D(0,1,0), Vector3D(0,0,0)));
     }
 
     void testVisitLineAdjacency()
@@ -712,7 +712,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(1));
-        QVERIFY(visitor.verifySegment(0, 1, 2, QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 1, 2, Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 
     void testVisitLinesAdjacencyIndexed()
@@ -805,7 +805,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(visitor.segmentCount(), uint(1));
-        QVERIFY(visitor.verifySegment(0, 1, 2, QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifySegment(0, 1, 2, Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 };
 
diff --git a/tests/auto/render/shadercache/tst_shadercache.cpp b/tests/auto/render/shadercache/tst_shadercache.cpp
index 1c70d4405..49628ef0f 100644
--- a/tests/auto/render/shadercache/tst_shadercache.cpp
+++ b/tests/auto/render/shadercache/tst_shadercache.cpp
@@ -131,6 +131,19 @@ void tst_ShaderCache::value()
     auto dnaC = ProgramDNA(54321);
     auto uncachedProgram = cache.getShaderProgramAndAddRef(dnaC, nodeIdB);
     QVERIFY(uncachedProgram == nullptr);
+
+    cache.clear();
+    // Test inserting nullptr.
+    cache.insert(dnaA, nodeIdA, nullptr);
+    bool wasPresent = false;
+    cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA, &wasPresent);
+    QCOMPARE(wasPresent, true);
+    QCOMPARE(cachedProgramA, nullptr);
+    cache.clear();
+    // Test wasPresent==false.
+    cachedProgramB = cache.getShaderProgramAndAddRef(dnaB, nodeIdB, &wasPresent);
+    QCOMPARE(wasPresent, false);
+    QCOMPARE(cachedProgramB, nullptr);
 }
 
 void tst_ShaderCache::removeRef()
diff --git a/tests/auto/render/transform/tst_transform.cpp b/tests/auto/render/transform/tst_transform.cpp
index ebb27953d..151baff76 100644
--- a/tests/auto/render/transform/tst_transform.cpp
+++ b/tests/auto/render/transform/tst_transform.cpp
@@ -49,7 +49,7 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(backendTransform.isEnabled(), false);
         QVERIFY(backendTransform.peerId().isNull());
-        QCOMPARE(backendTransform.transformMatrix(), QMatrix4x4());
+        QCOMPARE(convertToQMatrix4x4(backendTransform.transformMatrix()), QMatrix4x4());
     }
 
     void checkCleanupState()
@@ -71,7 +71,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendTransform.isEnabled(), false);
-        QCOMPARE(backendTransform.transformMatrix(), QMatrix4x4());
+        QCOMPARE(convertToQMatrix4x4(backendTransform.transformMatrix()), QMatrix4x4());
         QCOMPARE(backendTransform.rotation(), QQuaternion());
         QCOMPARE(backendTransform.scale(), QVector3D());
         QCOMPARE(backendTransform.translation(), QVector3D());
@@ -93,7 +93,7 @@ private Q_SLOTS:
             // THEN
             QCOMPARE(backendTransform.isEnabled(), true);
             QCOMPARE(backendTransform.peerId(), transform.id());
-            QCOMPARE(backendTransform.transformMatrix(), transform.matrix());
+            QCOMPARE(convertToQMatrix4x4(backendTransform.transformMatrix()), transform.matrix());
             QCOMPARE(backendTransform.rotation(), transform.rotation());
             QCOMPARE(backendTransform.scale(), transform.scale3D());
             QCOMPARE(backendTransform.translation(), transform.translation());
diff --git a/tests/auto/render/triangleboundingvolume/triangleboundingvolume.pro b/tests/auto/render/triangleboundingvolume/triangleboundingvolume.pro
index e88a997e2..dcbb2c17f 100644
--- a/tests/auto/render/triangleboundingvolume/triangleboundingvolume.pro
+++ b/tests/auto/render/triangleboundingvolume/triangleboundingvolume.pro
@@ -7,3 +7,4 @@ QT += 3dcore 3dcore-private 3drender 3drender-private testlib
 CONFIG += testcase
 
 SOURCES += tst_triangleboundingvolume.cpp
+
diff --git a/tests/auto/render/triangleboundingvolume/tst_triangleboundingvolume.cpp b/tests/auto/render/triangleboundingvolume/tst_triangleboundingvolume.cpp
index df375e777..b037c461f 100644
--- a/tests/auto/render/triangleboundingvolume/tst_triangleboundingvolume.cpp
+++ b/tests/auto/render/triangleboundingvolume/tst_triangleboundingvolume.cpp
@@ -47,43 +47,43 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::TriangleBoundingVolume volume = Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(),
-                                                                                                       QVector3D(),
-                                                                                                       QVector3D(),
-                                                                                                       QVector3D());
+                                                                                                       Vector3D(),
+                                                                                                       Vector3D(),
+                                                                                                       Vector3D());
 
         // THEN
         QCOMPARE(volume.id(), Qt3DCore::QNodeId());
-        QCOMPARE(volume.a(), QVector3D());
-        QCOMPARE(volume.b(), QVector3D());
-        QCOMPARE(volume.c(), QVector3D());
+        QCOMPARE(volume.a(), Vector3D());
+        QCOMPARE(volume.b(), Vector3D());
+        QCOMPARE(volume.c(), Vector3D());
         QCOMPARE(volume.type(), Qt3DRender::RayCasting::QBoundingVolume::Triangle);
     }
 
     void transformed_data()
     {
-        QTest::addColumn<QVector3D>("a");
-        QTest::addColumn<QVector3D>("b");
-        QTest::addColumn<QVector3D>("c");
+        QTest::addColumn<Vector3D>("a");
+        QTest::addColumn<Vector3D>("b");
+        QTest::addColumn<Vector3D>("c");
 
-        QTest::addColumn<QVector3D>("transformedA");
-        QTest::addColumn<QVector3D>("transformedB");
-        QTest::addColumn<QVector3D>("transformedC");
+        QTest::addColumn<Vector3D>("transformedA");
+        QTest::addColumn<Vector3D>("transformedB");
+        QTest::addColumn<Vector3D>("transformedC");
 
         QTest::newRow("onFarPlane")
-                << QVector3D(-1.0, 1.0, 0.0)
-                << QVector3D(0.0, -1.0, 0.0)
-                << QVector3D(1.0, 1.0, 0.0)
-                << QVector3D(-1.0, 1.0, -40.0)
-                << QVector3D(0.0, -1.0, -40.0)
-                << QVector3D(1.0, 1.0, -40.0);
+                << Vector3D(-1.0, 1.0, 0.0)
+                << Vector3D(0.0, -1.0, 0.0)
+                << Vector3D(1.0, 1.0, 0.0)
+                << Vector3D(-1.0, 1.0, -40.0)
+                << Vector3D(0.0, -1.0, -40.0)
+                << Vector3D(1.0, 1.0, -40.0);
 
         QTest::newRow("onNearPlane")
-                << QVector3D(-1.0, 1.0, 40.0)
-                << QVector3D(0.0, -1.0, 40.0)
-                << QVector3D(1.0, 1.0, 40.0)
-                << QVector3D(-1.0, 1.0, 0.0)
-                << QVector3D(0.0, -1.0, 0.0)
-                << QVector3D(1.0, 1.0, 0.0);
+                << Vector3D(-1.0, 1.0, 40.0)
+                << Vector3D(0.0, -1.0, 40.0)
+                << Vector3D(1.0, 1.0, 40.0)
+                << Vector3D(-1.0, 1.0, 0.0)
+                << Vector3D(0.0, -1.0, 0.0)
+                << Vector3D(1.0, 1.0, 0.0);
 
 
     }
@@ -91,12 +91,12 @@ private Q_SLOTS:
     void transformed()
     {
         // GIVEN
-        QFETCH(QVector3D, a);
-        QFETCH(QVector3D, b);
-        QFETCH(QVector3D, c);
-        QFETCH(QVector3D, transformedA);
-        QFETCH(QVector3D, transformedB);
-        QFETCH(QVector3D, transformedC);
+        QFETCH(Vector3D, a);
+        QFETCH(Vector3D, b);
+        QFETCH(Vector3D, c);
+        QFETCH(Vector3D, transformedA);
+        QFETCH(Vector3D, transformedB);
+        QFETCH(Vector3D, transformedC);
         Qt3DRender::Render::TriangleBoundingVolume volume(Qt3DCore::QNodeId(),
                                                           a,
                                                           b,
@@ -111,7 +111,7 @@ private Q_SLOTS:
         camera.setUpVector(QVector3D(0.0f, 1.0f, 0.0f));
         camera.setViewCenter(QVector3D(0.0f, 0.0f, 0.0f));
 
-        const QMatrix4x4 viewMatrix = camera.viewMatrix();
+        const Matrix4x4 viewMatrix(camera.viewMatrix());
 
         // WHEN
         volume.transform(viewMatrix);
@@ -125,61 +125,61 @@ private Q_SLOTS:
     void intersects_data()
     {
         QTest::addColumn<Qt3DRender::RayCasting::QRay3D>("ray");
-        QTest::addColumn<QVector3D>("a");
-        QTest::addColumn<QVector3D>("b");
-        QTest::addColumn<QVector3D>("c");
-        QTest::addColumn<QVector3D>("uvw");
+        QTest::addColumn<Vector3D>("a");
+        QTest::addColumn<Vector3D>("b");
+        QTest::addColumn<Vector3D>("c");
+        QTest::addColumn<Vector3D>("uvw");
         QTest::addColumn<float>("t");
         QTest::addColumn<bool>("isIntersecting");
 
         const float farPlaneDistance = 40.0;
 
         QTest::newRow("halfway_center")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(), QVector3D(0.0, 0.0, 1.0), farPlaneDistance)
-                << QVector3D(3.0, 1.5, 20.0)
-                << QVector3D(0.0, -1.5, 20.0)
-                << QVector3D(-3, 1.5, 20.0)
-                << QVector3D(0.25, 0.5, 0.25)
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(), Vector3D(0.0, 0.0, 1.0), farPlaneDistance)
+                << Vector3D(3.0, 1.5, 20.0)
+                << Vector3D(0.0, -1.5, 20.0)
+                << Vector3D(-3, 1.5, 20.0)
+                << Vector3D(0.25, 0.5, 0.25)
                 << 0.5f
                 << true;
         QTest::newRow("miss_halfway_center_too_short")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(), QVector3D(0.0, 0.0, 1.0), farPlaneDistance * 0.25f)
-                << QVector3D(3.0, 1.5, 20.0)
-                << QVector3D(0.0, -1.5, 20.0)
-                << QVector3D(-3, 1.5, 20.0)
-                << QVector3D()
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(), Vector3D(0.0, 0.0, 1.0), farPlaneDistance * 0.25f)
+                << Vector3D(3.0, 1.5, 20.0)
+                << Vector3D(0.0, -1.5, 20.0)
+                << Vector3D(-3, 1.5, 20.0)
+                << Vector3D()
                 << 0.0f
                 << false;
         QTest::newRow("far_center")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(), QVector3D(0.0, 0.0, 1.0), farPlaneDistance)
-                << QVector3D(3.0, 1.5, 40.0)
-                << QVector3D(0.0, -1.5, 40.0)
-                << QVector3D(-3, 1.5, 40.0)
-                << QVector3D(0.25, 0.5, 0.25)
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(), Vector3D(0.0, 0.0, 1.0), farPlaneDistance)
+                << Vector3D(3.0, 1.5, 40.0)
+                << Vector3D(0.0, -1.5, 40.0)
+                << Vector3D(-3, 1.5, 40.0)
+                << Vector3D(0.25, 0.5, 0.25)
                 << 1.0f
                 << true;
         QTest::newRow("near_center")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(), QVector3D(0.0, 0.0, 1.0), 1.0f)
-                << QVector3D(3.0, 1.5, 0.0)
-                << QVector3D(0.0, -1.5, 0.0)
-                << QVector3D(-3, 1.5, 0.0)
-                << QVector3D(0.25, 0.5, 0.25)
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(), Vector3D(0.0, 0.0, 1.0), 1.0f)
+                << Vector3D(3.0, 1.5, 0.0)
+                << Vector3D(0.0, -1.5, 0.0)
+                << Vector3D(-3, 1.5, 0.0)
+                << Vector3D(0.25, 0.5, 0.25)
                 << 0.0f
                 << true;
         QTest::newRow("above_miss_center")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(0.0, 2.0, 0.0), QVector3D(0.0, 2.0, 1.0), 1.0f)
-                << QVector3D(3.0, 1.5, 0.0)
-                << QVector3D(0.0, -1.5, 0.0)
-                << QVector3D(-3, 1.5, 0.0)
-                << QVector3D()
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(0.0, 2.0, 0.0), Vector3D(0.0, 2.0, 1.0), 1.0f)
+                << Vector3D(3.0, 1.5, 0.0)
+                << Vector3D(0.0, -1.5, 0.0)
+                << Vector3D(-3, 1.5, 0.0)
+                << Vector3D()
                 << 0.0f
                 << false;
         QTest::newRow("below_miss_center")
-                << Qt3DRender::RayCasting::QRay3D(QVector3D(0.0, -2.0, 0.0), QVector3D(0.0, -2.0, 1.0), 1.0f)
-                << QVector3D(3.0, 1.5, 0.0)
-                << QVector3D(0.0, -1.5, 0.0)
-                << QVector3D(-3, 1.5, 0.0)
-                << QVector3D()
+                << Qt3DRender::RayCasting::QRay3D(Vector3D(0.0, -2.0, 0.0), Vector3D(0.0, -2.0, 1.0), 1.0f)
+                << Vector3D(3.0, 1.5, 0.0)
+                << Vector3D(0.0, -1.5, 0.0)
+                << Vector3D(-3, 1.5, 0.0)
+                << Vector3D()
                 << 0.0f
                 << false;
     }
@@ -188,15 +188,15 @@ private Q_SLOTS:
     {
         // GIVEN
         QFETCH(Qt3DRender::RayCasting::QRay3D, ray);
-        QFETCH(QVector3D, a);
-        QFETCH(QVector3D, b);
-        QFETCH(QVector3D, c);
-        QFETCH(QVector3D, uvw);
+        QFETCH(Vector3D, a);
+        QFETCH(Vector3D, b);
+        QFETCH(Vector3D, c);
+        QFETCH(Vector3D, uvw);
         QFETCH(float, t);
         QFETCH(bool, isIntersecting);
 
         // WHEN
-        QVector3D tmp_uvw;
+        Vector3D tmp_uvw;
         float tmp_t;
         const bool shouldBeIntersecting = Qt3DRender::Render::intersectsSegmentTriangle(ray,
                                                                                         a, b, c,
diff --git a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
index c6db3f62d..2f6d283be 100644
--- a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
+++ b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
@@ -353,10 +353,10 @@ private Q_SLOTS:
 
         QVector<Qt3DRender::Render::TriangleBoundingVolume *> v =
                 QVector<Qt3DRender::Render::TriangleBoundingVolume *>()
-                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), QVector3D(0, 1, 0), QVector3D(1, 0, -1), QVector3D(-1, 0, -1))
-                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), QVector3D(-1, 0, -1), QVector3D(1, 0, -1), QVector3D(0, 0, 1))
-                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), QVector3D(0, 0, 1), QVector3D(0, 1, 0), QVector3D(-1, 0, -1))
-                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), QVector3D(0, 1, 0), QVector3D(0, 0, 1), QVector3D(1, 0, -1));
+                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), Vector3D(0, 1, 0), Vector3D(1, 0, -1), Vector3D(-1, 0, -1))
+                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), Vector3D(-1, 0, -1), Vector3D(1, 0, -1), Vector3D(0, 0, 1))
+                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), Vector3D(0, 0, 1), Vector3D(0, 1, 0), Vector3D(-1, 0, -1))
+                << new Qt3DRender::Render::TriangleBoundingVolume(Qt3DCore::QNodeId(), Vector3D(0, 1, 0), Vector3D(0, 0, 1), Vector3D(1, 0, -1));
 
         QTest::newRow("indexedMesh") << customIndexedGeometryRenderer() << v;
         QTest::newRow("nonIndexedMesh") << customNonIndexedGeometryRenderer() << v;
diff --git a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
index 9b6481423..4205d598e 100644
--- a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
+++ b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
@@ -49,7 +49,7 @@ public:
 
     }
 
-    virtual void visit(uint andx, const QVector3D &a, uint bndx, const QVector3D &b, uint cndx, const QVector3D &c)
+    virtual void visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
     {
         m_triangles.push_back(TestTriangle(andx, a, bndx, b, cndx, c));
     }
@@ -69,7 +69,7 @@ public:
         return m_triangles.size();
     }
 
-    bool verifyTriangle(uint triangle, uint andx, uint bndx, uint cndx, QVector3D a, QVector3D b, QVector3D c) const
+    bool verifyTriangle(uint triangle, uint andx, uint bndx, uint cndx, Vector3D a, Vector3D b, Vector3D c) const
     {
         if (triangle >= uint(m_triangles.size()))
             return false;
@@ -89,13 +89,13 @@ private:
     struct TestTriangle
     {
         uint abcndx[3];
-        QVector3D abc[3];
+        Vector3D abc[3];
         TestTriangle()
         {
             abcndx[0] = abcndx[1] = abcndx[2] = uint(-1);
         }
 
-        TestTriangle(uint andx, const QVector3D &a, uint bndx, const QVector3D &b, uint cndx, const QVector3D &c)
+        TestTriangle(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
         {
             abcndx[0] = andx;
             abcndx[1] = bndx;
@@ -194,7 +194,7 @@ private Q_SLOTS:
         positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float);
         positionAttribute->setVertexSize(3);
         positionAttribute->setCount(6);
-        positionAttribute->setByteStride(3*4);
+        positionAttribute->setByteStride(0);
         positionAttribute->setByteOffset(0);
         positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
         geometry->addAttribute(positionAttribute.data());
@@ -220,8 +220,8 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 2);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 5,4,3, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 5,4,3, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
     }
 
     void testVisitTrianglesIndexed()
@@ -331,11 +331,11 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 5);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 5,4,3, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(2, 0,1,5, QVector3D(0,0,1), QVector3D(1,0,0), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifyTriangle(3, 2,3,4, QVector3D(0,1,0), QVector3D(0,0,1), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifyTriangle(4, 4,2,0, QVector3D(1,0,0), QVector3D(0,1,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 5,4,3, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(2, 0,1,5, Vector3D(0,0,1), Vector3D(1,0,0), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(3, 2,3,4, Vector3D(0,1,0), Vector3D(0,0,1), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifyTriangle(4, 4,2,0, Vector3D(1,0,0), Vector3D(0,1,0), Vector3D(0,0,1)));
     }
 
     void testVisitTriangleStrip()
@@ -407,10 +407,10 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 4);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 3,2,1, QVector3D(0,0,1), QVector3D(0,1,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifyTriangle(2, 4,3,2, QVector3D(1,0,0), QVector3D(0,0,1), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifyTriangle(3, 5,4,3, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 3,2,1, Vector3D(0,0,1), Vector3D(0,1,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifyTriangle(2, 4,3,2, Vector3D(1,0,0), Vector3D(0,0,1), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(3, 5,4,3, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
     }
 
     void testVisitTriangleStripIndexed()
@@ -517,14 +517,14 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 8);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 3,2,1, QVector3D(0,0,1), QVector3D(0,1,0), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifyTriangle(2, 4,3,2, QVector3D(1,0,0), QVector3D(0,0,1), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifyTriangle(3, 5,4,3, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(4, 0,1,5, QVector3D(0,0,1), QVector3D(1,0,0), QVector3D(0,1,0)));
-        QVERIFY(visitor.verifyTriangle(5, 4,0,1, QVector3D(1,0,0), QVector3D(0,0,1), QVector3D(1,0,0)));
-        QVERIFY(visitor.verifyTriangle(6, 3,4,0, QVector3D(0,0,1), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(7, 2,3,4, QVector3D(0,1,0), QVector3D(0,0,1), QVector3D(1,0,0)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 3,2,1, Vector3D(0,0,1), Vector3D(0,1,0), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifyTriangle(2, 4,3,2, Vector3D(1,0,0), Vector3D(0,0,1), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(3, 5,4,3, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(4, 0,1,5, Vector3D(0,0,1), Vector3D(1,0,0), Vector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(5, 4,0,1, Vector3D(1,0,0), Vector3D(0,0,1), Vector3D(1,0,0)));
+        QVERIFY(visitor.verifyTriangle(6, 3,4,0, Vector3D(0,0,1), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(7, 2,3,4, Vector3D(0,1,0), Vector3D(0,0,1), Vector3D(1,0,0)));
     }
 
     void testVisitTriangleFan()
@@ -596,10 +596,10 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 4);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 3,2,0, QVector3D(0,0,1), QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(2, 4,3,0, QVector3D(1,0,0), QVector3D(0,0,1), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(3, 5,4,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 3,2,0, Vector3D(0,0,1), Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(2, 4,3,0, Vector3D(1,0,0), Vector3D(0,0,1), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(3, 5,4,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
     }
 
     void testVisitTriangleFanIndexed()
@@ -700,10 +700,10 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 4);
-        QVERIFY(visitor.verifyTriangle(0, 2,1,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 3,2,0, QVector3D(0,0,1), QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(2, 4,3,0, QVector3D(1,0,0), QVector3D(0,0,1), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(3, 5,4,0, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 2,1,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 3,2,0, Vector3D(0,0,1), Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(2, 4,3,0, Vector3D(1,0,0), Vector3D(0,0,1), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(3, 5,4,0, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,0,1)));
     }
 
     void testVisitTrianglesAdjacency()
@@ -775,7 +775,7 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 1);
-        QVERIFY(visitor.verifyTriangle(0, 4,2,0, QVector3D(1,0,0), QVector3D(0,1,0), QVector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(0, 4,2,0, Vector3D(1,0,0), Vector3D(0,1,0), Vector3D(0,0,1)));
     }
 
     void testVisitTrianglesAdjacencyIndexed()
@@ -883,8 +883,8 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 2);
-        QVERIFY(visitor.verifyTriangle(0, 4,2,0, QVector3D(1,0,0), QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 3,0,5, QVector3D(0,0,1), QVector3D(0,0,1), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(0, 4,2,0, Vector3D(1,0,0), Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 3,0,5, Vector3D(0,0,1), Vector3D(0,0,1), Vector3D(0,1,0)));
     }
 
     void testVisitTriangleStripAdjacency()
@@ -969,8 +969,8 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 2);
-        QVERIFY(visitor.verifyTriangle(0, 4,2,0, QVector3D(1,0,0), QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 6,4,2, QVector3D(1,1,1), QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(0, 4,2,0, Vector3D(1,0,0), Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 6,4,2, Vector3D(1,1,1), Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 
     void testVisitTriangleStripAdjacencyIndexed()
@@ -1074,8 +1074,8 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(visitor.triangleCount() == 2);
-        QVERIFY(visitor.verifyTriangle(0, 4,2,0, QVector3D(1,0,0), QVector3D(0,1,0), QVector3D(0,0,1)));
-        QVERIFY(visitor.verifyTriangle(1, 5,4,2, QVector3D(0,1,0), QVector3D(1,0,0), QVector3D(0,1,0)));
+        QVERIFY(visitor.verifyTriangle(0, 4,2,0, Vector3D(1,0,0), Vector3D(0,1,0), Vector3D(0,0,1)));
+        QVERIFY(visitor.verifyTriangle(1, 5,4,2, Vector3D(0,1,0), Vector3D(1,0,0), Vector3D(0,1,0)));
     }
 };
 
diff --git a/tests/auto/render/uniform/tst_uniform.cpp b/tests/auto/render/uniform/tst_uniform.cpp
index b8578b294..213646369 100644
--- a/tests/auto/render/uniform/tst_uniform.cpp
+++ b/tests/auto/render/uniform/tst_uniform.cpp
@@ -107,7 +107,7 @@ private Q_SLOTS:
         }
         {
             // GIVEN
-            UniformValue v(QVector3D(572.0f, 355.0f, 383.0f));
+            UniformValue v(Vector3D(572.0f, 355.0f, 383.0f));
             // THEN
             QCOMPARE(v.constData<float>()[0], 572.0f);
             QCOMPARE(v.constData<float>()[1], 355.0f);
@@ -116,7 +116,7 @@ private Q_SLOTS:
         }
         {
             // GIVEN
-            UniformValue v(QVector4D(355.0f, 383.0f, 1340.0f, 1603.0f));
+            UniformValue v(Vector4D(355.0f, 383.0f, 1340.0f, 1603.0f));
             // THEN
             QCOMPARE(v.constData<float>()[0], 355.0f);
             QCOMPARE(v.constData<float>()[1], 383.0f);
@@ -340,7 +340,7 @@ private Q_SLOTS:
     void checkComparison()
     {
         // GIVEN
-        const UniformValue v1(QVector3D(454.0f, 883.0f, 572.0f));
+        const UniformValue v1(Vector3D(454.0f, 883.0f, 572.0f));
         UniformValue v2(454.0f);
 
         // THEN
@@ -348,13 +348,13 @@ private Q_SLOTS:
         QVERIFY(v1 != v2);
 
         // WHEN
-        v2 = UniformValue::fromVariant(QVector3D(454.0f, 883.0f, 572.0f));
+        v2 = UniformValue::fromVariant(QVariant::fromValue(Vector3D(454.0f, 883.0f, 572.0f)));
         // THEN
         QVERIFY(v1 == v2);
         QVERIFY(!(v1 != v2));
 
         // WHEN
-        v2 = UniformValue::fromVariant(QVector3D(454.0f, 883.0f, 572.0f));
+        v2 = UniformValue::fromVariant(QVariant::fromValue(Vector3D(454.0f, 883.0f, 572.0f)));
         // THEN
         QVERIFY(v1 == v2);
         QVERIFY(!(v1 != v2));
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index c076aa21e..67ddccd9b 100644
--- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
+++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
@@ -179,7 +179,8 @@ private Q_SLOTS:
 
         // THEN
         // See scene file to find translation
-        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("eyePosition"), camera->viewMatrix()).value<QVector3D>(), camera->viewMatrix() * (QVector3D(1.0f, 1.0f, 1.0f) + QVector3D(0.0f, 5.0f, 0.0f)));
+        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("eyePosition"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
+                 Matrix4x4(camera->viewMatrix()) * (Vector3D(1.0f, 1.0f, 1.0f) + Vector3D(0.0f, 5.0f, 0.0f)));
     }
 
     void checkRunModelToWorld()
@@ -219,7 +220,8 @@ private Q_SLOTS:
 
         // THEN
         // See scene file to find translation
-        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("position"), camera->viewMatrix()).value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f) + QVector3D(5.0f, 5.0f, 5.0f));
+        QCOMPARE(backendShaderData->getTransformedProperty(QLatin1String("position"), Matrix4x4(camera->viewMatrix())).value<Vector3D>(),
+                 Vector3D(1.0f, 1.0f, 1.0f) + Vector3D(5.0f, 5.0f, 5.0f));
     }
 };