Render: Use SIMD Vectors and Matrices in the backend

Change-Id: I19b3b2f8fcb06eb2bc600ebe370465dd15a8eabc
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

76 files changed, 1161 insertions, 799 deletions

diff --git a/src/core/resources/qresourcemanager_p.h b/src/core/resources/qresourcemanager_p.h
index 038f3d551..e620b40d1 100644
--- a/src/core/resources/qresourcemanager_p.h
+++ b/src/core/resources/qresourcemanager_p.h
@@ -60,6 +60,8 @@
 #include <limits>
 
 #include <Qt3DCore/private/qhandle_p.h>
+#include <QtCore/private/qsimd_p.h>
+#include <Qt3DCore/private/qt3dcore-config_p.h>
 
 // Silence complaints about unreferenced local variables in
 // ArrayAllocatingPolicy::deallocateBuckets() when the compiler
@@ -313,7 +315,17 @@ private:
     void allocateBucket()
     {
         // no free handle, allocate a new
-        Bucket *b = new Bucket;
+        Bucket *b = nullptr;
+        // allocate aligned memory
+#if QT_CONFIG(qt3d_simd_avx2) && defined(__AVX2__) && defined(QT_COMPILER_SUPPORTS_AVX2)
+        b = static_cast<Bucket*>(_mm_malloc(sizeof(Bucket), 32));
+#elif QT_CONFIG(qt3d_simd_sse2) && defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2)
+        b = static_cast<Bucket*>(_mm_malloc(sizeof(Bucket), 16));
+#else
+        b = static_cast<Bucket*>(malloc(sizeof(Bucket)));
+#endif
+        // placement new
+        new (b) Bucket;
 
         b->header.next = firstBucket;
         firstBucket = b;
@@ -329,7 +341,16 @@ private:
         Bucket *b = firstBucket;
         while (b) {
             Bucket *n = b->header.next;
-            delete b;
+            // Call dtor explicitly
+            b->~Bucket();
+            // Release aligned memory
+#if QT_CONFIG(qt3d_simd_avx2) && defined(__AVX2__) && defined(QT_COMPILER_SUPPORTS_AVX2)
+            _mm_free(b);
+#elif QT_CONFIG(qt3d_simd_sse2) && defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2)
+            _mm_free(b);
+#else
+            free(b);
+#endif
             b = n;
         }
     }
diff --git a/src/core/transforms/matrix4x4_p.h b/src/core/transforms/matrix4x4_p.h
index 18f5db4c3..d100d3d3b 100644
--- a/src/core/transforms/matrix4x4_p.h
+++ b/src/core/transforms/matrix4x4_p.h
@@ -83,4 +83,16 @@ QT_END_NAMESPACE
 
 #endif
 
+template<typename UsingType>
+Q_ALWAYS_INLINE QMatrix4x4 convertToQMatrix4x4(const UsingType &v)
+{
+    return v.toQMatrix4x4();
+}
+
+template<>
+Q_ALWAYS_INLINE QMatrix4x4 convertToQMatrix4x4<QMatrix4x4>(const QMatrix4x4 &v)
+{
+    return v;
+}
+
 #endif // QT3DCORE_MATRIX4X4_P_H
diff --git a/src/core/transforms/vector3d_p.h b/src/core/transforms/vector3d_p.h
index 6467d7686..80e936903 100644
--- a/src/core/transforms/vector3d_p.h
+++ b/src/core/transforms/vector3d_p.h
@@ -74,4 +74,16 @@ QT_END_NAMESPACE
 
 #endif
 
+template<typename UsingType>
+Q_ALWAYS_INLINE QVector3D convertToQVector3D(const UsingType &v)
+{
+    return v.toQVector3D();
+}
+
+template<>
+Q_ALWAYS_INLINE QVector3D convertToQVector3D<QVector3D>(const QVector3D &v)
+{
+    return v;
+}
+
 #endif // QT3DCORE_VECTOR3D_P_H
diff --git a/src/core/transforms/vector4d_p.h b/src/core/transforms/vector4d_p.h
index a03dc234f..dbfaffffd 100644
--- a/src/core/transforms/vector4d_p.h
+++ b/src/core/transforms/vector4d_p.h
@@ -74,4 +74,16 @@ QT_END_NAMESPACE
 
 #endif
 
+template<typename UsingType>
+Q_ALWAYS_INLINE QVector4D convertToQVector4D(const UsingType &v)
+{
+    return v.toQVector4D();
+}
+
+template<>
+Q_ALWAYS_INLINE QVector4D convertToQVector4D<QVector4D>(const QVector4D &v)
+{
+    return v;
+}
+
 #endif // QT3DCORE_VECTOR4D_P_H
diff --git a/src/quick3d/quick3dscene2d/items/scene2d.cpp b/src/quick3d/quick3dscene2d/items/scene2d.cpp
index 4abc7cf42..67bb1a671 100644
--- a/src/quick3d/quick3dscene2d/items/scene2d.cpp
+++ b/src/quick3d/quick3dscene2d/items/scene2d.cpp
@@ -466,10 +466,10 @@ void Scene2D::handlePickEvent(int type, const Qt3DRender::QPickEventPtr &ev)
         CoordinateReader reader(renderer()->nodeManagers());
         if (reader.setGeometry(entity->renderComponent<GeometryRenderer>(),
                                QAttribute::defaultTextureCoordinateAttributeName())) {
-            QVector4D c0 = reader.getCoordinate(pickTriangle->vertex1Index());
-            QVector4D c1 = reader.getCoordinate(pickTriangle->vertex2Index());
-            QVector4D c2 = reader.getCoordinate(pickTriangle->vertex3Index());
-            QVector4D ci = c0 * pickTriangle->uvw().x()
+            Vector4D c0 = reader.getCoordinate(pickTriangle->vertex1Index());
+            Vector4D c1 = reader.getCoordinate(pickTriangle->vertex2Index());
+            Vector4D c2 = reader.getCoordinate(pickTriangle->vertex3Index());
+            Vector4D ci = c0 * pickTriangle->uvw().x()
                            + c1 * pickTriangle->uvw().y() + c2 * pickTriangle->uvw().z();
             ci.setW(1.0f);
 
diff --git a/src/render/aligned_malloc_p.h b/src/render/aligned_malloc_p.h
new file mode 100644
index 000000000..a2a619b03
--- /dev/null
+++ b/src/render/aligned_malloc_p.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_RENDER_ALIGNED_MALLOC_P_H
+#define QT3DRENDER_RENDER_ALIGNED_MALLOC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/private/qsimd_p.h>
+#include <Qt3DCore/private/qt3dcore-config_p.h>
+
+#if QT_CONFIG(qt3d_simd_avx2) && defined(__AVX2__) && defined(QT_COMPILER_SUPPORTS_AVX2)
+# define QT3D_ALIGNED_MALLOC(s) _mm_malloc(s, 32)
+#elif QT_CONFIG(qt3d_simd_sse2) && defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2)
+# define QT3D_ALIGNED_MALLOC(s) _mm_malloc(s, 16)
+#else
+    #define QT3D_ALIGNED_MALLOC(s) malloc(s)
+#endif
+
+#if (QT_CONFIG(qt3d_simd_avx2) && defined(__AVX2__) && defined(QT_COMPILER_SUPPORTS_AVX2)) || (QT_CONFIG(qt3d_simd_sse2) && defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2))
+# define QT3D_ALIGNED_FREE(ptr) _mm_free(ptr)
+#else
+# define QT3D_ALIGNED_FREE(ptr) free(ptr)
+#endif
+
+#define QT3D_ALIGNED_MALLOC_AND_FREE() \
+    static void *operator new(size_t s) \
+    { \
+        return QT3D_ALIGNED_MALLOC(s); \
+    } \
+    static void operator delete(void *ptr) \
+    { \
+        QT3D_ALIGNED_FREE(ptr); \
+    }
+
+#endif // QT3DRENDER_RENDER_ALIGNED_MALLOC_P_H
diff --git a/src/render/backend/cameralens.cpp b/src/render/backend/cameralens.cpp
index e127b5885..b540b24c8 100644
--- a/src/render/backend/cameralens.cpp
+++ b/src/render/backend/cameralens.cpp
@@ -105,23 +105,25 @@ void CameraLens::setRenderAspect(QRenderAspect *renderAspect)
     m_renderAspect = renderAspect;
 }
 
-QMatrix4x4 CameraLens::viewMatrix(const QMatrix4x4 &worldTransform)
+Matrix4x4 CameraLens::viewMatrix(const Matrix4x4 &worldTransform)
 {
-    const QVector4D position = worldTransform * QVector4D(0.0f, 0.0f, 0.0f, 1.0f);
+    const Vector4D position = worldTransform * Vector4D(0.0f, 0.0f, 0.0f, 1.0f);
     // OpenGL convention is looking down -Z
-    const QVector4D viewDirection = worldTransform * QVector4D(0.0f, 0.0f, -1.0f, 0.0f);
-    const QVector4D upVector = worldTransform * QVector4D(0.0f, 1.0f, 0.0f, 0.0f);
+    const Vector4D viewDirection = worldTransform * Vector4D(0.0f, 0.0f, -1.0f, 0.0f);
+    const Vector4D upVector = worldTransform * Vector4D(0.0f, 1.0f, 0.0f, 0.0f);
 
     QMatrix4x4 m;
-    m.lookAt(position.toVector3D(), (position + viewDirection).toVector3D(), upVector.toVector3D());
-    return m;
+    m.lookAt(convertToQVector3D(Vector3D(position)),
+             convertToQVector3D(Vector3D(position + viewDirection)),
+             convertToQVector3D(Vector3D(upVector)));
+    return Matrix4x4(m);
 }
 
 void CameraLens::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
 {
     const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QCameraLensData>>(change);
     const auto &data = typedChange->data;
-    m_projection = data.projectionMatrix;
+    m_projection = Matrix4x4(data.projectionMatrix);
     m_exposure = data.exposure;
 }
 
@@ -160,7 +162,7 @@ void CameraLens::notifySceneBoundingVolume(const Sphere &sphere, QNodeCommand::C
     }
 }
 
-void CameraLens::setProjection(const QMatrix4x4 &projection)
+void CameraLens::setProjection(const Matrix4x4 &projection)
 {
     m_projection = projection;
 }
@@ -178,7 +180,7 @@ void CameraLens::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 
         if (propertyChange->propertyName() == QByteArrayLiteral("projectionMatrix")) {
             QMatrix4x4 projectionMatrix = propertyChange->value().value<QMatrix4x4>();
-            m_projection = projectionMatrix;
+            m_projection = Matrix4x4(projectionMatrix);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("exposure")) {
             setExposure(propertyChange->value().toFloat());
         }
@@ -212,7 +214,7 @@ void CameraLens::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 }
 
 bool CameraLens::viewMatrixForCamera(EntityManager* manager, Qt3DCore::QNodeId cameraId,
-                                     QMatrix4x4 &viewMatrix, QMatrix4x4 &projectionMatrix)
+                                     Matrix4x4 &viewMatrix, Matrix4x4 &projectionMatrix)
 {
     Entity *camNode = manager->lookupResource(cameraId);
     if (!camNode)
diff --git a/src/render/backend/cameralens_p.h b/src/render/backend/cameralens_p.h
index 1afeeda24..a177c258c 100644
--- a/src/render/backend/cameralens_p.h
+++ b/src/render/backend/cameralens_p.h
@@ -53,7 +53,7 @@
 
 #include <Qt3DRender/private/backendnode_p.h>
 #include <Qt3DCore/private/qnodecommand_p.h>
-#include <QMatrix4x4>
+#include <Qt3DCore/private/matrix4x4_p.h>
 #include <QRectF>
 
 QT_BEGIN_NAMESPACE
@@ -89,10 +89,10 @@ public:
 
     void setRenderAspect(QRenderAspect* renderAspect);
 
-    QMatrix4x4 viewMatrix(const QMatrix4x4 &worldTransform);
+    Matrix4x4 viewMatrix(const Matrix4x4 &worldTransform);
 
-    void setProjection(const QMatrix4x4 &projection);
-    inline QMatrix4x4 projection() const { return m_projection; }
+    void setProjection(const Matrix4x4 &projection);
+    inline Matrix4x4 projection() const { return m_projection; }
 
     void setExposure(float exposure);
     inline float exposure() const { return m_exposure; }
@@ -101,7 +101,7 @@ public:
     void notifySceneBoundingVolume(const Sphere &sphere, Qt3DCore::QNodeCommand::CommandId commandId);
 
     static bool viewMatrixForCamera(EntityManager *manager, Qt3DCore::QNodeId cameraId,
-                                    QMatrix4x4 &viewMatrix, QMatrix4x4 &projectionMatrix);
+                                    Matrix4x4 &viewMatrix, Matrix4x4 &projectionMatrix);
 
 private:
     void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) Q_DECL_FINAL;
@@ -110,8 +110,8 @@ private:
                                     Qt3DCore::QNodeCommand::CommandId commandId);
 
     QRenderAspect *m_renderAspect;
-    QMatrix4x4 m_projection;
     Qt3DCore::QNodeCommand::CommandId m_pendingViewAllCommand;
+    Matrix4x4 m_projection;
     float m_exposure;
 };
 
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index 914ac2ec3..a0f4bcb97 100644
--- a/src/render/backend/entity.cpp
+++ b/src/render/backend/entity.cpp
@@ -287,12 +287,12 @@ QVector<Entity *> Entity::children() const
     return childrenVector;
 }
 
-QMatrix4x4 *Entity::worldTransform()
+Matrix4x4 *Entity::worldTransform()
 {
     return m_nodeManagers->worldMatrixManager()->data(m_worldTransform);
 }
 
-const QMatrix4x4 *Entity::worldTransform() const
+const Matrix4x4 *Entity::worldTransform() const
 {
     return m_nodeManagers->worldMatrixManager()->data(m_worldTransform);
 }
diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h
index d2227965d..12eec98f6 100644
--- a/src/render/backend/entity_p.h
+++ b/src/render/backend/entity_p.h
@@ -104,8 +104,8 @@ public:
     QVector<Entity *> children() const;
     bool hasChildren() const { return !m_childrenHandles.empty(); }
 
-    QMatrix4x4 *worldTransform();
-    const QMatrix4x4 *worldTransform() const;
+    Matrix4x4 *worldTransform();
+    const Matrix4x4 *worldTransform() const;
     Sphere *localBoundingVolume() const { return m_localBoundingVolume.data(); }
     Sphere *worldBoundingVolume() const { return m_worldBoundingVolume.data(); }
     Sphere *worldBoundingVolumeWithChildren() const { return m_worldBoundingVolumeWithChildren.data(); }
diff --git a/src/render/backend/handle_types_p.h b/src/render/backend/handle_types_p.h
index 4062aadeb..26b1cec88 100644
--- a/src/render/backend/handle_types_p.h
+++ b/src/render/backend/handle_types_p.h
@@ -53,11 +53,10 @@
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DCore/private/qhandle_p.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
 
 QT_BEGIN_NAMESPACE
 
-class QMatrix4x4;
-
 namespace Qt3DRender {
 
 class QTextureImageData;
@@ -108,7 +107,7 @@ typedef Qt3DCore::QHandle<FrameGraphNode *> HFrameGraphNode;
 typedef Qt3DCore::QHandle<Layer> HLayer;
 typedef Qt3DCore::QHandle<LevelOfDetail> HLevelOfDetail;
 typedef Qt3DCore::QHandle<Material> HMaterial;
-typedef Qt3DCore::QHandle<QMatrix4x4> HMatrix;
+typedef Qt3DCore::QHandle<Matrix4x4> HMatrix;
 typedef Qt3DCore::QHandle<OpenGLVertexArrayObject> HVao;
 typedef Qt3DCore::QHandle<Shader> HShader;
 typedef Qt3DCore::QHandle<ShaderBuilder> HShaderBuilder;
diff --git a/src/render/backend/managers_p.h b/src/render/backend/managers_p.h
index b811057cb..8a33b1122 100644
--- a/src/render/backend/managers_p.h
+++ b/src/render/backend/managers_p.h
@@ -52,6 +52,7 @@
 //
 
 #include <Qt3DCore/private/qresourcemanager_p.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
 #include <Qt3DRender/private/rendertargetoutput_p.h>
 #include <Qt3DRender/private/cameralens_p.h>
 #include <Qt3DRender/private/filterkey_p.h>
@@ -188,7 +189,7 @@ public:
 };
 
 class MatrixManager : public Qt3DCore::QResourceManager<
-        QMatrix4x4,
+        Matrix4x4,
         Qt3DCore::QNodeId,
         Qt3DCore::NonLockingPolicy>
 {
diff --git a/src/render/backend/nodemanagers.cpp b/src/render/backend/nodemanagers.cpp
index f5de64dae..b42b7fc96 100644
--- a/src/render/backend/nodemanagers.cpp
+++ b/src/render/backend/nodemanagers.cpp
@@ -172,7 +172,7 @@ MaterialManager *NodeManagers::manager<Material>() const Q_DECL_NOTHROW
 }
 
 template<>
-MatrixManager *NodeManagers::manager<QMatrix4x4*>() const Q_DECL_NOTHROW
+MatrixManager *NodeManagers::manager<Matrix4x4>() const Q_DECL_NOTHROW
 {
     return m_worldMatrixManager;
 }
diff --git a/src/render/backend/pointsvisitor.cpp b/src/render/backend/pointsvisitor.cpp
index 663488357..750182b19 100644
--- a/src/render/backend/pointsvisitor.cpp
+++ b/src/render/backend/pointsvisitor.cpp
@@ -72,7 +72,7 @@ void traverseCoordinatesIndexed(Index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx;
-    QVector3D abc;
+    Vector3D abc;
     while (i < indexInfo.count) {
         ndx = indices[i];
         const uint idx = ndx * verticesStride;
@@ -94,7 +94,7 @@ void traverseCoordinates(Vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx = 0;
-    QVector3D abc;
+    Vector3D abc;
     while (ndx < vertexInfo.count) {
         const uint idx = ndx * verticesStride;
         for (uint j = 0; j < maxVerticesDataSize; ++j)
diff --git a/src/render/backend/pointsvisitor_p.h b/src/render/backend/pointsvisitor_p.h
index 9d44ffec5..1614f185b 100644
--- a/src/render/backend/pointsvisitor_p.h
+++ b/src/render/backend/pointsvisitor_p.h
@@ -52,6 +52,7 @@
 //
 
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/vector3d_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -75,7 +76,7 @@ public:
     void apply(const Qt3DCore::QEntity *entity);
     void apply(const GeometryRenderer *renderer, const Qt3DCore::QNodeId id);
 
-    virtual void visit(uint ndx, const QVector3D &c) = 0;
+    virtual void visit(uint ndx, const Vector3D &c) = 0;
 
 protected:
     NodeManagers *m_manager;
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 995d63f3c..da3d551e6 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -148,16 +148,16 @@ static QRectF resolveViewport(const QRectF &fractionalViewport, const QSize &sur
                   fractionalViewport.height() * surfaceSize.height());
 }
 
-static QMatrix4x4 getProjectionMatrix(const CameraLens *lens)
+static Matrix4x4 getProjectionMatrix(const CameraLens *lens)
 {
     if (!lens)
         qWarning() << "[Qt3D Renderer] No Camera Lens found. Add a CameraSelector to your Frame Graph or make sure that no entities will be rendered.";
-    return lens ? lens->projection() : QMatrix4x4();
+    return lens ? lens->projection() : Matrix4x4();
 }
 
 UniformValue RenderView::standardUniformValue(RenderView::StandardUniform standardUniformType,
                                               Entity *entity,
-                                              const QMatrix4x4 &model) const
+                                              const Matrix4x4 &model) const
 {
     switch (standardUniformType) {
     case ModelMatrix:
@@ -182,24 +182,26 @@ UniformValue RenderView::standardUniformValue(RenderView::StandardUniform standa
     case InverseModelViewMatrix:
         return UniformValue((m_data.m_viewMatrix * model).inverted());
     case InverseViewProjectionMatrix: {
-        const QMatrix4x4 viewProjectionMatrix = getProjectionMatrix(m_data.m_renderCameraLens) * m_data.m_viewMatrix;
+        const Matrix4x4 viewProjectionMatrix = getProjectionMatrix(m_data.m_renderCameraLens) * m_data.m_viewMatrix;
         return UniformValue(viewProjectionMatrix.inverted());
     }
     case InverseModelViewProjectionMatrix:
-        return UniformValue((m_data.m_viewProjectionMatrix * model).inverted(0));
+        return UniformValue((m_data.m_viewProjectionMatrix * model).inverted());
     case ModelNormalMatrix:
-        return UniformValue(model.normalMatrix());
+        return UniformValue(convertToQMatrix4x4(model).normalMatrix());
     case ModelViewNormalMatrix:
-        return UniformValue((m_data.m_viewMatrix * model).normalMatrix());
+        return UniformValue(convertToQMatrix4x4(m_data.m_viewMatrix * model).normalMatrix());
     case ViewportMatrix: {
         QMatrix4x4 viewportMatrix;
+        // TO DO: Implement on Matrix4x4
         viewportMatrix.viewport(resolveViewport(m_viewport, m_surfaceSize));
-        return UniformValue(viewportMatrix);
+        return UniformValue(Matrix4x4(viewportMatrix));
     }
     case InverseViewportMatrix: {
         QMatrix4x4 viewportMatrix;
+        // TO DO: Implement on Matrix4x4
         viewportMatrix.viewport(resolveViewport(m_viewport, m_surfaceSize));
-        return UniformValue(viewportMatrix.inverted());
+        return UniformValue(Matrix4x4(viewportMatrix.inverted()));
     }
     case AspectRatio:
         return float(m_surfaceSize.width()) / float(m_surfaceSize.height());
@@ -494,20 +496,6 @@ void RenderView::setRenderer(Renderer *renderer)
     m_manager = renderer->nodeManagers();
 }
 
-class LightSourceCompare
-{
-public:
-    LightSourceCompare(Entity *node) { p = node->worldBoundingVolume()->center(); }
-    bool operator()(const LightSource &a, const LightSource &b) const {
-        const float distA = p.distanceToPoint(a.entity->worldBoundingVolume()->center());
-        const float distB = p.distanceToPoint(b.entity->worldBoundingVolume()->center());
-        return distA < distB;
-    }
-
-private:
-    QVector3D p;
-};
-
 void RenderView::addClearBuffers(const ClearBuffers *cb) {
     QClearBuffers::BufferTypeFlags type = cb->type();
 
@@ -579,7 +567,7 @@ QVector<RenderCommand *> RenderView::buildDrawRenderCommands(const QVector<Entit
                 // Project the camera-to-object-center vector onto the camera
                 // view vector. This gives a depth value suitable as the key
                 // for BackToFront sorting.
-                command->m_depth = QVector3D::dotProduct(entity->worldBoundingVolume()->center() - m_data.m_eyePos, m_data.m_eyeViewDir);
+                command->m_depth = Vector3D::dotProduct(entity->worldBoundingVolume()->center() - m_data.m_eyePos, m_data.m_eyeViewDir);
 
                 command->m_geometry = geometryHandle;
                 command->m_geometryRenderer = geometryRendererHandle;
@@ -605,8 +593,15 @@ QVector<RenderCommand *> RenderView::buildDrawRenderCommands(const QVector<Entit
                 // Replace with more sophisticated mechanisms later.
                 // Copy vector so that we can sort it concurrently and we only want to sort the one for the current command
                 QVector<LightSource> lightSources = m_lightSources;
-                if (lightSources.size() > 1)
-                    std::sort(lightSources.begin(), lightSources.end(), LightSourceCompare(entity));
+                if (lightSources.size() > 1) {
+                    const Vector3D entityCenter = entity->worldBoundingVolume()->center();
+                    std::sort(lightSources.begin(), lightSources.end(),
+                              [&] (const LightSource &a, const LightSource &b) {
+                        const float distA = entityCenter.distanceToPoint(a.entity->worldBoundingVolume()->center());
+                        const float distB = entityCenter.distanceToPoint(b.entity->worldBoundingVolume()->center());
+                        return distA < distB;
+                    });
+                }
 
                 ParameterInfoList globalParameters = passData.parameterInfo;
                 // setShaderAndUniforms can initialize a localData
@@ -733,21 +728,21 @@ QVector<RenderCommand *> RenderView::buildComputeRenderCommands(const QVector<En
 void RenderView::updateMatrices()
 {
     if (m_data.m_renderCameraNode && m_data.m_renderCameraLens && m_data.m_renderCameraLens->isEnabled()) {
-        const QMatrix4x4 cameraWorld = *(m_data.m_renderCameraNode->worldTransform());
+        const Matrix4x4 cameraWorld = *(m_data.m_renderCameraNode->worldTransform());
         setViewMatrix(m_data.m_renderCameraLens->viewMatrix(cameraWorld));
 
         setViewProjectionMatrix(m_data.m_renderCameraLens->projection() * viewMatrix());
         //To get the eyePosition of the camera, we need to use the inverse of the
         //camera's worldTransform matrix.
-        const QMatrix4x4 inverseWorldTransform = viewMatrix().inverted();
-        const QVector3D eyePosition(inverseWorldTransform.column(3));
+        const Matrix4x4 inverseWorldTransform = viewMatrix().inverted();
+        const Vector3D eyePosition(inverseWorldTransform.column(3));
         setEyePosition(eyePosition);
 
         // Get the viewing direction of the camera. Use the normal matrix to
         // ensure non-uniform scale works too.
-        QMatrix3x3 normalMat = m_data.m_viewMatrix.normalMatrix();
+        const QMatrix3x3 normalMat = convertToQMatrix4x4(m_data.m_viewMatrix).normalMatrix();
         // dir = normalize(QVector3D(0, 0, -1) * normalMat)
-        setEyeViewDirection(QVector3D(-normalMat(2, 0), -normalMat(2, 1), -normalMat(2, 2)).normalized());
+        setEyeViewDirection(Vector3D(-normalMat(2, 0), -normalMat(2, 1), -normalMat(2, 2)).normalized());
     }
 }
 
@@ -775,7 +770,7 @@ void RenderView::setStandardUniformValue(ShaderParameterPack &uniformPack,
                                          int glslNameId,
                                          int nameId,
                                          Entity *entity,
-                                         const QMatrix4x4 &worldTransform) const
+                                         const Matrix4x4 &worldTransform) const
 {
     uniformPack.setUniform(glslNameId, standardUniformValue(ms_standardUniformSetters[nameId], entity, worldTransform));
 }
@@ -960,7 +955,7 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
                     !shaderStorageBlockNamesIds.isEmpty() || !attributeNamesIds.isEmpty()) {
 
                 // Set default standard uniforms without bindings
-                QMatrix4x4 worldTransform = *(entity->worldTransform());
+                const Matrix4x4 worldTransform = *(entity->worldTransform());
                 for (const int uniformNameId : uniformNamesIds) {
                     if (ms_standardUniformSetters.contains(uniformNameId))
                         setStandardUniformValue(command->m_parameterPack, uniformNameId, uniformNameId, entity, worldTransform);
@@ -1006,7 +1001,7 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
                     if (lightIdx == MAX_LIGHTS)
                         break;
                     Entity *lightEntity = lightSource.entity;
-                    const QVector3D worldPos = lightEntity->worldBoundingVolume()->center();
+                    const Vector3D worldPos = lightEntity->worldBoundingVolume()->center();
                     for (Light *light : lightSource.lights) {
                         if (!light->isEnabled())
                             continue;
@@ -1021,13 +1016,13 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
                         // Note: implicit conversion of values to UniformValue
                         setUniformValue(command->m_parameterPack, LIGHT_POSITION_NAMES[lightIdx], worldPos);
                         setUniformValue(command->m_parameterPack, LIGHT_TYPE_NAMES[lightIdx], int(QAbstractLight::PointLight));
-                        setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[lightIdx], QVector3D(1.0f, 1.0f, 1.0f));
+                        setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[lightIdx], Vector3D(1.0f, 1.0f, 1.0f));
                         setUniformValue(command->m_parameterPack, LIGHT_INTENSITY_NAMES[lightIdx], 0.5f);
 
                         // There is no risk in doing that even if multithreaded
                         // since we are sure that a shaderData is unique for a given light
                         // and won't ever be referenced as a Component either
-                        QMatrix4x4 *worldTransform = lightEntity->worldTransform();
+                        Matrix4x4 *worldTransform = lightEntity->worldTransform();
                         if (worldTransform)
                             shaderData->updateWorldTransform(*worldTransform);
 
@@ -1042,9 +1037,9 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
                 // If no active light sources and no environment light, add a default light
                 if (activeLightSources.isEmpty() && !environmentLight) {
                     // Note: implicit conversion of values to UniformValue
-                    setUniformValue(command->m_parameterPack, LIGHT_POSITION_NAMES[0], QVector3D(10.0f, 10.0f, 0.0f));
+                    setUniformValue(command->m_parameterPack, LIGHT_POSITION_NAMES[0], Vector3D(10.0f, 10.0f, 0.0f));
                     setUniformValue(command->m_parameterPack, LIGHT_TYPE_NAMES[0], int(QAbstractLight::PointLight));
-                    setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[0], QVector3D(1.0f, 1.0f, 1.0f));
+                    setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[0], Vector3D(1.0f, 1.0f, 1.0f));
                     setUniformValue(command->m_parameterPack, LIGHT_INTENSITY_NAMES[0], 0.5f);
                 }
 
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index 21d25a528..4c8acfe96 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -67,6 +67,7 @@
 #include <Qt3DRender/private/qblitframebuffer_p.h>
 
 #include <Qt3DCore/private/qframeallocator_p.h>
+#include <Qt3DRender/private/aligned_malloc_p.h>
 
 // TODO: Move out once this is all refactored
 #include <Qt3DRender/private/renderviewjobutils_p.h>
@@ -98,14 +99,14 @@ typedef QPair<QString, ActivePropertyContent > ActiveProperty;
 
 struct Q_AUTOTEST_EXPORT Plane
 {
-    explicit Plane(const QVector4D &planeEquation)
+    explicit Plane(const Vector4D &planeEquation)
         : planeEquation(planeEquation)
-        , normal(planeEquation.toVector3D().normalized())
-        , d(planeEquation.w() / planeEquation.toVector3D().length())
+        , normal(Vector3D(planeEquation).normalized())
+        , d(planeEquation.w() / Vector3D(planeEquation).length())
     {}
 
-    const QVector4D planeEquation;
-    const QVector3D normal;
+    const Vector4D planeEquation;
+    const Vector3D normal;
     const float d;
 };
 
@@ -136,6 +137,8 @@ public:
     RenderView();
     ~RenderView();
 
+    QT3D_ALIGNED_MALLOC_AND_FREE()
+
     // TODO: Add a way to specify a sort predicate for the RenderCommands
     void sort();
 
@@ -153,17 +156,17 @@ public:
     inline void setRenderCameraEntity(Entity *renderCameraNode) Q_DECL_NOTHROW { m_data.m_renderCameraNode = renderCameraNode; }
     inline Entity *renderCameraEntity() const Q_DECL_NOTHROW { return m_data.m_renderCameraNode; }
 
-    inline void setViewMatrix(const QMatrix4x4 &viewMatrix) Q_DECL_NOTHROW { m_data.m_viewMatrix = viewMatrix; }
-    inline QMatrix4x4 viewMatrix() const Q_DECL_NOTHROW { return m_data.m_viewMatrix; }
+    inline void setViewMatrix(const Matrix4x4 &viewMatrix) Q_DECL_NOTHROW { m_data.m_viewMatrix = viewMatrix; }
+    inline Matrix4x4 viewMatrix() const Q_DECL_NOTHROW { return m_data.m_viewMatrix; }
 
-    inline void setViewProjectionMatrix(const QMatrix4x4 &viewProjectionMatrix) Q_DECL_NOTHROW { m_data.m_viewProjectionMatrix = viewProjectionMatrix; }
-    inline QMatrix4x4 viewProjectionMatrix() const Q_DECL_NOTHROW { return m_data.m_viewProjectionMatrix; }
+    inline void setViewProjectionMatrix(const Matrix4x4 &viewProjectionMatrix) Q_DECL_NOTHROW { m_data.m_viewProjectionMatrix = viewProjectionMatrix; }
+    inline Matrix4x4 viewProjectionMatrix() const Q_DECL_NOTHROW { return m_data.m_viewProjectionMatrix; }
 
-    inline void setEyePosition(const QVector3D &eyePos) Q_DECL_NOTHROW { m_data.m_eyePos = eyePos; }
-    inline QVector3D eyePosition() const Q_DECL_NOTHROW { return m_data.m_eyePos; }
+    inline void setEyePosition(const Vector3D &eyePos) Q_DECL_NOTHROW { m_data.m_eyePos = eyePos; }
+    inline Vector3D eyePosition() const Q_DECL_NOTHROW { return m_data.m_eyePos; }
 
-    inline void setEyeViewDirection(const QVector3D &dir) Q_DECL_NOTHROW { m_data.m_eyeViewDir = dir; }
-    inline QVector3D eyeViewDirection() const Q_DECL_NOTHROW { return m_data.m_eyeViewDir; }
+    inline void setEyeViewDirection(const Vector3D &dir) Q_DECL_NOTHROW { m_data.m_eyeViewDir = dir; }
+    inline Vector3D eyeViewDirection() const Q_DECL_NOTHROW { return m_data.m_eyeViewDir; }
 
     inline void appendLayerFilter(const Qt3DCore::QNodeId layerFilterId) Q_DECL_NOTHROW { m_data.m_layerFilterIds.push_back(layerFilterId); }
     inline Qt3DCore::QNodeIdVector layerFilters() const Q_DECL_NOTHROW { return m_data.m_layerFilterIds; }
@@ -260,12 +263,12 @@ public:
         Entity *m_renderCameraNode;
         const TechniqueFilter *m_techniqueFilter;
         const RenderPassFilter *m_passFilter;
-        QMatrix4x4 m_viewMatrix;
-        QMatrix4x4 m_viewProjectionMatrix;
+        Matrix4x4 m_viewMatrix;
+        Matrix4x4 m_viewProjectionMatrix;
         Qt3DCore::QNodeIdVector m_layerFilterIds;
         QVector<Qt3DRender::QSortPolicy::SortType> m_sortingTypes;
-        QVector3D m_eyePos;
-        QVector3D m_eyeViewDir;
+        Vector3D m_eyePos;
+        Vector3D m_eyeViewDir;
         Qt3DCore::QNodeIdVector m_proximityFilterIds;
     };
 
@@ -285,7 +288,6 @@ private:
                               Entity *entity,
                               const QVector<LightSource> &activeLightSources,
                               EnvironmentLight *environmentLight) const;
-
     mutable QThreadStorage<UniformBlockValueBuilder*> m_localData;
 
     Qt3DCore::QNodeId m_renderCaptureNodeId;
@@ -360,14 +362,14 @@ private:
 
     UniformValue standardUniformValue(StandardUniform standardUniformType,
                                       Entity *entity,
-                                      const QMatrix4x4 &model) const;
+                                      const Matrix4x4 &model) const;
 
     void setUniformValue(ShaderParameterPack &uniformPack, int nameId, const UniformValue &value) const;
     void setStandardUniformValue(ShaderParameterPack &uniformPack,
                                  int glslNameId,
                                  int nameId,
                                  Entity *entity,
-                                 const QMatrix4x4 &worldTransform) const;
+                                 const Matrix4x4 &worldTransform) const;
     void setUniformBlockValue(ShaderParameterPack &uniformPack,
                               Shader *shader,
                               const ShaderUniformBlock &block,
diff --git a/src/render/backend/renderviewbuilder.cpp b/src/render/backend/renderviewbuilder.cpp
index ce5a63565..47ef6cb03 100644
--- a/src/render/backend/renderviewbuilder.cpp
+++ b/src/render/backend/renderviewbuilder.cpp
@@ -334,7 +334,7 @@ RenderViewBuilder::RenderViewBuilder(Render::FrameGraphNode *leafNode, int rende
     , m_lightGathererJob(Render::LightGathererPtr::create())
     , m_renderableEntityFilterJob(RenderableEntityFilterPtr::create())
     , m_computableEntityFilterJob(ComputableEntityFilterPtr::create())
-    , m_frustumCullingJob(Render::FrustumCullingJobPtr::create())
+    , m_frustumCullingJob(new Render::FrustumCullingJob())
     , m_syncFrustumCullingJob(SynchronizerJobPtr::create(SyncFrustumCulling(m_renderViewJob, m_frustumCullingJob), JobTypes::SyncFrustumCulling))
     , m_setClearDrawBufferIndexJob(SynchronizerJobPtr::create(SetClearDrawBufferIndex(m_renderViewJob), JobTypes::ClearBufferDrawIndex))
     , m_syncFilterEntityByLayerJob()
diff --git a/src/render/backend/segmentsvisitor.cpp b/src/render/backend/segmentsvisitor.cpp
index 96e2b3b6c..a3a5d059c 100644
--- a/src/render/backend/segmentsvisitor.cpp
+++ b/src/render/backend/segmentsvisitor.cpp
@@ -86,7 +86,7 @@ void traverseSegmentsIndexed(Index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     while (i < indexInfo.count) {
         for (uint u = 0; u < 2; ++u) {
             ndx[u] = indices[i + u];
@@ -112,7 +112,7 @@ void traverseSegments(Vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     while (i < vertexInfo.count) {
         for (uint u = 0; u < 2; ++u) {
             ndx[u] = (i + u);
@@ -139,7 +139,7 @@ void traverseSegmentStripIndexed(Index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     ndx[0] = indices[0];
     uint idx = ndx[0] * verticesStride;
     for (uint j = 0; j < maxVerticesDataSize; ++j)
@@ -180,7 +180,7 @@ void traverseSegmentStrip(Vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     ndx[0] = i;
     uint idx = ndx[0] * verticesStride;
     for (uint j = 0; j < maxVerticesDataSize; ++j)
@@ -218,7 +218,7 @@ void traverseSegmentAdjacencyIndexed(Index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     while (i < n) {
         for (uint u = 0; u < 2; ++u) {
             ndx[u] = indices[i + u];
@@ -245,7 +245,7 @@ void traverseSegmentAdjacency(Vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[2];
-    QVector3D abc[2];
+    Vector3D abc[2];
     while (i < n) {
         for (uint u = 0; u < 2; ++u) {
             ndx[u] = (i + u);
diff --git a/src/render/backend/segmentsvisitor_p.h b/src/render/backend/segmentsvisitor_p.h
index 21867b0d5..cd5df1268 100644
--- a/src/render/backend/segmentsvisitor_p.h
+++ b/src/render/backend/segmentsvisitor_p.h
@@ -52,6 +52,7 @@
 //
 
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/vector3d_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -75,8 +76,8 @@ public:
     void apply(const Qt3DCore::QEntity *entity);
     void apply(const GeometryRenderer *renderer, const Qt3DCore::QNodeId id);
 
-    virtual void visit(uint andx, const QVector3D &a,
-                       uint bndx, const QVector3D &b) = 0;
+    virtual void visit(uint andx, const Vector3D &a,
+                       uint bndx, const Vector3D &b) = 0;
 
 protected:
     NodeManagers *m_manager;
diff --git a/src/render/backend/transform.cpp b/src/render/backend/transform.cpp
index 636c2d103..20574d6f7 100644
--- a/src/render/backend/transform.cpp
+++ b/src/render/backend/transform.cpp
@@ -64,7 +64,7 @@ void Transform::cleanup()
     m_rotation = QQuaternion();
     m_scale = QVector3D();
     m_translation = QVector3D();
-    m_transformMatrix = QMatrix4x4();
+    m_transformMatrix = Matrix4x4();
     QBackendNode::setEnabled(false);
 }
 
@@ -78,7 +78,7 @@ void Transform::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &ch
     updateMatrix();
 }
 
-QMatrix4x4 Transform::transformMatrix() const
+Matrix4x4 Transform::transformMatrix() const
 {
     return m_transformMatrix;
 }
@@ -125,7 +125,7 @@ void Transform::updateMatrix()
     m.translate(m_translation);
     m.rotate(m_rotation);
     m.scale(m_scale);
-    m_transformMatrix = m;
+    m_transformMatrix = Matrix4x4(m);
 }
 
 } // namespace Render
diff --git a/src/render/backend/transform_p.h b/src/render/backend/transform_p.h
index 4b58e3cae..5c625ba8e 100644
--- a/src/render/backend/transform_p.h
+++ b/src/render/backend/transform_p.h
@@ -54,7 +54,7 @@
 #include <Qt3DRender/private/backendnode_p.h>
 #include <QtGui/qquaternion.h>
 #include <QtGui/qvector3d.h>
-#include <QMatrix4x4>
+#include <Qt3DCore/private/matrix4x4_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -71,7 +71,7 @@ public:
     Transform();
     void cleanup();
 
-    QMatrix4x4 transformMatrix() const;
+    Matrix4x4 transformMatrix() const;
     QVector3D scale() const;
     QQuaternion rotation() const;
     QVector3D translation() const;
@@ -83,7 +83,7 @@ public:
 private:
     void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) Q_DECL_FINAL;
 
-    QMatrix4x4 m_transformMatrix;
+    Matrix4x4 m_transformMatrix;
     QQuaternion m_rotation;
     QVector3D m_scale;
     QVector3D m_translation;
diff --git a/src/render/backend/triangleboundingvolume.cpp b/src/render/backend/triangleboundingvolume.cpp
index ca2d26897..be5206657 100644
--- a/src/render/backend/triangleboundingvolume.cpp
+++ b/src/render/backend/triangleboundingvolume.cpp
@@ -49,35 +49,35 @@ namespace Render {
 // Note: a, b, c in clockwise order
 // RealTime Collision Detection page 192
 bool intersectsSegmentTriangle(const RayCasting::QRay3D &ray,
-                               const QVector3D &a,
-                               const QVector3D &b,
-                               const QVector3D &c,
-                               QVector3D &uvw,
+                               const Vector3D &a,
+                               const Vector3D &b,
+                               const Vector3D &c,
+                               Vector3D &uvw,
                                float &t)
 {
-    const QVector3D ab = b - a;
-    const QVector3D ac = c - a;
-    const QVector3D qp = (ray.origin() - ray.point(ray.distance()));
+    const Vector3D ab = b - a;
+    const Vector3D ac = c - a;
+    const Vector3D qp = (ray.origin() - ray.point(ray.distance()));
 
-    const QVector3D n = QVector3D::crossProduct(ab, ac);
-    const float d = QVector3D::dotProduct(qp, n);
+    const Vector3D n = Vector3D::crossProduct(ab, ac);
+    const float d = Vector3D::dotProduct(qp, n);
 
     if (d <= 0.0f)
         return false;
 
-    const QVector3D ap = ray.origin() - a;
-    t = QVector3D::dotProduct(ap, n);
+    const Vector3D ap = ray.origin() - a;
+    t = Vector3D::dotProduct(ap, n);
 
     if (t < 0.0f || t > d)
         return false;
 
-    const QVector3D e = QVector3D::crossProduct(qp, ap);
-    uvw.setY(QVector3D::dotProduct(ac, e));
+    const Vector3D e = Vector3D::crossProduct(qp, ap);
+    uvw.setY(Vector3D::dotProduct(ac, e));
 
     if (uvw.y() < 0.0f || uvw.y() > d)
         return false;
 
-    uvw.setZ(-QVector3D::dotProduct(ab, e));
+    uvw.setZ(-Vector3D::dotProduct(ab, e));
 
     if (uvw.z() < 0.0f || uvw.y() + uvw.z() > d)
         return false;
@@ -99,7 +99,7 @@ TriangleBoundingVolume::TriangleBoundingVolume()
 /*!
     The vertices a, b, c are assumed to be in counter clockwise order.
  */
-TriangleBoundingVolume::TriangleBoundingVolume(Qt3DCore::QNodeId id, const QVector3D &a, const QVector3D &b, const QVector3D &c)
+TriangleBoundingVolume::TriangleBoundingVolume(Qt3DCore::QNodeId id, const Vector3D &a, const Vector3D &b, const Vector3D &c)
     : QBoundingVolume()
     , m_id(id)
     , m_a(a)
@@ -112,10 +112,10 @@ Qt3DCore::QNodeId TriangleBoundingVolume::id() const
     return m_id;
 }
 
-bool TriangleBoundingVolume::intersects(const RayCasting::QRay3D &ray, QVector3D *q, QVector3D *uvw) const
+bool TriangleBoundingVolume::intersects(const RayCasting::QRay3D &ray, Vector3D *q, Vector3D *uvw) const
 {
     float t = 0.0f;
-    QVector3D uvwr;
+    Vector3D uvwr;
     const float intersected = intersectsSegmentTriangle(ray, m_c, m_b, m_a, uvwr, t);
 
     if (intersected) {
@@ -132,41 +132,41 @@ TriangleBoundingVolume::Type TriangleBoundingVolume::type() const
     return RayCasting::QBoundingVolume::Triangle;
 }
 
-QVector3D TriangleBoundingVolume::a() const
+Vector3D TriangleBoundingVolume::a() const
 {
     return m_a;
 }
 
-QVector3D TriangleBoundingVolume::b() const
+Vector3D TriangleBoundingVolume::b() const
 {
     return m_b;
 }
 
-QVector3D TriangleBoundingVolume::c() const
+Vector3D TriangleBoundingVolume::c() const
 {
     return m_c;
 }
 
-void TriangleBoundingVolume::setA(const QVector3D &a)
+void TriangleBoundingVolume::setA(const Vector3D &a)
 {
     m_a = a;
 }
 
-void TriangleBoundingVolume::setB(const QVector3D &b)
+void TriangleBoundingVolume::setB(const Vector3D &b)
 {
     m_b = b;
 }
 
-void TriangleBoundingVolume::setC(const QVector3D &c)
+void TriangleBoundingVolume::setC(const Vector3D &c)
 {
     m_c = c;
 }
 
-TriangleBoundingVolume TriangleBoundingVolume::transformed(const QMatrix4x4 &mat) const
+TriangleBoundingVolume TriangleBoundingVolume::transformed(const Matrix4x4 &mat) const
 {
-    const QVector3D tA = mat * m_a;
-    const QVector3D tB = mat * m_b;
-    const QVector3D tC = mat * m_c;
+    const Vector3D tA = mat * m_a;
+    const Vector3D tB = mat * m_b;
+    const Vector3D tC = mat * m_c;
     return TriangleBoundingVolume(id(), tA, tB, tC);
 }
 
diff --git a/src/render/backend/triangleboundingvolume_p.h b/src/render/backend/triangleboundingvolume_p.h
index 3192ad456..dcdd972ae 100644
--- a/src/render/backend/triangleboundingvolume_p.h
+++ b/src/render/backend/triangleboundingvolume_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/private/qboundingvolume_p.h>
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
 #include <QVector3D>
 
 QT_BEGIN_NAMESPACE
@@ -62,10 +63,10 @@ namespace Qt3DRender {
 namespace Render {
 
 Q_AUTOTEST_EXPORT bool intersectsSegmentTriangle(const RayCasting::QRay3D &ray,
-                                                 const QVector3D &a,
-                                                 const QVector3D &b,
-                                                 const QVector3D &c,
-                                                 QVector3D &uvw,
+                                                 const Vector3D &a,
+                                                 const Vector3D &b,
+                                                 const Vector3D &c,
+                                                 Vector3D &uvw,
                                                  float &t);
 
 class Q_AUTOTEST_EXPORT TriangleBoundingVolume : public RayCasting::QBoundingVolume
@@ -73,25 +74,25 @@ class Q_AUTOTEST_EXPORT TriangleBoundingVolume : public RayCasting::QBoundingVol
 public:
     TriangleBoundingVolume();
     explicit TriangleBoundingVolume(Qt3DCore::QNodeId id,
-                                    const QVector3D &a,
-                                    const QVector3D &b,
-                                    const QVector3D &c);
+                                    const Vector3D &a,
+                                    const Vector3D &b,
+                                    const Vector3D &c);
 
     Qt3DCore::QNodeId id() const Q_DECL_FINAL;
-    bool intersects(const RayCasting::QRay3D &ray, QVector3D *q, QVector3D *uvw) const Q_DECL_FINAL;
+    bool intersects(const RayCasting::QRay3D &ray, Vector3D *q, Vector3D *uvw) const Q_DECL_FINAL;
     Type type() const  Q_DECL_FINAL;
 
-    QVector3D a() const;
-    QVector3D b() const;
-    QVector3D c() const;
+    Vector3D a() const;
+    Vector3D b() const;
+    Vector3D c() const;
 
-    void setA(const QVector3D &a);
-    void setB(const QVector3D &b);
-    void setC(const QVector3D &c);
+    void setA(const Vector3D &a);
+    void setB(const Vector3D &b);
+    void setC(const Vector3D &c);
 
-    TriangleBoundingVolume transformed(const QMatrix4x4 &mat) const;
+    TriangleBoundingVolume transformed(const Matrix4x4 &mat) const;
 
-    inline TriangleBoundingVolume &transform(const QMatrix4x4 &mat)
+    inline TriangleBoundingVolume &transform(const Matrix4x4 &mat)
     {
         *this = transformed(mat);
         return *this;
@@ -99,7 +100,7 @@ public:
 
 private:
     Qt3DCore::QNodeId m_id;
-    QVector3D m_a, m_b, m_c;
+    Vector3D m_a, m_b, m_c;
 };
 
 } // namespace Render
diff --git a/src/render/backend/trianglesextractor.cpp b/src/render/backend/trianglesextractor.cpp
index e7a36dab3..2ddb425a0 100644
--- a/src/render/backend/trianglesextractor.cpp
+++ b/src/render/backend/trianglesextractor.cpp
@@ -68,7 +68,7 @@ QVector<RayCasting::QBoundingVolume *> TrianglesExtractor::extract(const Qt3DCor
     return m_volumes;
 }
 
-void TrianglesExtractor::visit(uint andx, const QVector3D &a, uint bndx, const QVector3D &b, uint cndx, const QVector3D &c)
+void TrianglesExtractor::visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
 {
     Q_UNUSED(andx); Q_UNUSED(bndx); Q_UNUSED(cndx);
     m_volumes.push_back(new TriangleBoundingVolume(m_nodeId, a, b, c));
diff --git a/src/render/backend/trianglesextractor_p.h b/src/render/backend/trianglesextractor_p.h
index 8772d9a72..7dc92d8e2 100644
--- a/src/render/backend/trianglesextractor_p.h
+++ b/src/render/backend/trianglesextractor_p.h
@@ -71,9 +71,9 @@ public:
     QVector<RayCasting::QBoundingVolume *> extract(const Qt3DCore::QNodeId id);
 
 private:
-    void visit(uint andx, const QVector3D &a,
-               uint bndx, const QVector3D &b,
-               uint cndx, const QVector3D &c) Q_DECL_OVERRIDE;
+    void visit(uint andx, const Vector3D &a,
+               uint bndx, const Vector3D &b,
+               uint cndx, const Vector3D &c) Q_DECL_OVERRIDE;
 
     GeometryRenderer *m_renderer;
     QVector<RayCasting::QBoundingVolume *> m_volumes;
diff --git a/src/render/backend/trianglesvisitor.cpp b/src/render/backend/trianglesvisitor.cpp
index 57538c8d7..4a05d8f19 100644
--- a/src/render/backend/trianglesvisitor.cpp
+++ b/src/render/backend/trianglesvisitor.cpp
@@ -89,7 +89,7 @@ void traverseTrianglesIndexed(index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < indexInfo.count) {
         for (uint u = 0; u < 3; ++u) {
             ndx[u] = indices[i + u];
@@ -115,7 +115,7 @@ void traverseTriangles(vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < vertexInfo.count) {
         for (uint u = 0; u < 3; ++u) {
             ndx[u] = (i + u);
@@ -151,7 +151,7 @@ void traverseTriangleStripIndexed(index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < indexInfo.count - 2) {
         bool degenerate = false;
         for (uint u = 0; u < 3; ++u) {
@@ -182,7 +182,7 @@ void traverseTriangleStrip(vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < vertexInfo.count - 2) {
         for (uint u = 0; u < 3; ++u) {
             ndx[u] = (i + u);
@@ -208,7 +208,7 @@ void traverseTriangleFanIndexed(index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
 
     for (uint j = 0; j < maxVerticesDataSize; ++j) {
         abc[0][j] = vertices[static_cast<int>(indices[0]) * verticesStride + j];
@@ -238,7 +238,7 @@ void traverseTriangleFan(vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
 
     for (uint j = 0; j < maxVerticesDataSize; ++j) {
         abc[0][j] = vertices[j];
@@ -272,7 +272,7 @@ void traverseTriangleAdjacencyIndexed(index *indices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < indexInfo.count) {
         for (uint u = 0; u < 6; u += 2) {
             ndx[u / 2] = indices[i + u];
@@ -298,7 +298,7 @@ void traverseTriangleAdjacency(Vertex *vertices,
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
     uint ndx[3];
-    QVector3D abc[3];
+    Vector3D abc[3];
     while (i < vertexInfo.count) {
         for (uint u = 0; u < 6; u += 2) {
             ndx[u / 2] = (i + u);
@@ -313,10 +313,10 @@ void traverseTriangleAdjacency(Vertex *vertices,
 }
 
 template<typename Coordinate>
-QVector4D readCoordinate(const BufferInfo &info, Coordinate *coordinates, uint index)
+Vector4D readCoordinate(const BufferInfo &info, Coordinate *coordinates, uint index)
 {
     const uint stride = info.byteStride / sizeof(Coordinate);
-    QVector4D ret(0, 0, 0, 1.0f);
+    Vector4D ret(0, 0, 0, 1.0f);
     coordinates += stride * index;
     for (uint e = 0; e < info.dataSize; ++e)
         ret[e] = coordinates[e];
@@ -340,7 +340,7 @@ typename EnumToType<v>::type *castToType(const QByteArray &u, uint byteOffset)
     return reinterpret_cast< typename EnumToType<v>::type *>(u.constData() + byteOffset);
 }
 
-QVector4D readBuffer(const BufferInfo &info, uint index)
+Vector4D readBuffer(const BufferInfo &info, uint index)
 {
     switch (info.type) {
     case QAttribute::Byte:
@@ -362,7 +362,7 @@ QVector4D readBuffer(const BufferInfo &info, uint index)
     default:
         break;
     }
-    return QVector4D();
+    return Vector4D();
 }
 
 template<typename Index, typename Visitor>
@@ -509,7 +509,7 @@ bool CoordinateReader::setGeometry(const GeometryRenderer *renderer, const QStri
     return true;
 }
 
-QVector4D CoordinateReader::getCoordinate(uint vertexIndex)
+Vector4D CoordinateReader::getCoordinate(uint vertexIndex)
 {
     return readBuffer(m_bufferInfo, vertexIndex);
 }
diff --git a/src/render/backend/trianglesvisitor_p.h b/src/render/backend/trianglesvisitor_p.h
index 9428857ac..ee206f1c9 100644
--- a/src/render/backend/trianglesvisitor_p.h
+++ b/src/render/backend/trianglesvisitor_p.h
@@ -54,6 +54,8 @@
 #include <Qt3DCore/qnodeid.h>
 #include <Qt3DRender/QAttribute>
 #include <Qt3DRender/private/bufferutils_p.h>
+#include <Qt3DCore/private/vector3d_p.h>
+#include <Qt3DCore/private/vector4d_p.h>
 
 #include <private/qt3drender_global_p.h>
 
@@ -81,9 +83,9 @@ public:
     void apply(const Qt3DCore::QEntity *entity);
     void apply(const GeometryRenderer *renderer, const Qt3DCore::QNodeId id);
 
-    virtual void visit(uint andx, const QVector3D &a,
-                       uint bndx, const QVector3D &b,
-                       uint cndx, const QVector3D &c) = 0;
+    virtual void visit(uint andx, const Vector3D &a,
+                       uint bndx, const Vector3D &b,
+                       uint cndx, const Vector3D &c) = 0;
 
 protected:
     NodeManagers *m_manager;
@@ -102,7 +104,7 @@ public:
 
     bool setGeometry(const GeometryRenderer *renderer, const QString &attributeName);
 
-    QVector4D getCoordinate(uint vertexIndex);
+    Vector4D getCoordinate(uint vertexIndex);
 
 protected:
     NodeManagers *m_manager;
diff --git a/src/render/backend/uniform.cpp b/src/render/backend/uniform.cpp
index 03220a219..aedba5375 100644
--- a/src/render/backend/uniform.cpp
+++ b/src/render/backend/uniform.cpp
@@ -47,10 +47,20 @@ namespace Render {
 namespace {
 
 const int qNodeIdTypeId = qMetaTypeId<Qt3DCore::QNodeId>();
+const int qVector3DTypeId = qMetaTypeId<Vector3D>();
+const int qVector4DTypeId = qMetaTypeId<Vector4D>();
+const int qMatrix4x4TypeId = qMetaTypeId<Matrix4x4>();
 
 // glUniform*fv/glUniform*iv/glUniform*uiv -> only handles sizeof(float)/sizeof(int)
 int byteSizeForMetaType(int type)
 {
+    if (type == qMatrix4x4TypeId)
+        return sizeof(Matrix4x4);
+    if (type ==  qVector3DTypeId)
+        return sizeof(Vector3D);
+    if (type ==  qVector4DTypeId)
+        return sizeof(Vector4D);
+
     switch (type) {
     case QMetaType::Bool:
     case QMetaType::Int:
@@ -88,9 +98,9 @@ int byteSizeForMetaType(int type)
     case QMetaType::QVector4D:
     case QMetaType::QColor:
         return 4 * sizeof(float);
-
     case QMetaType::QMatrix4x4:
         return 16 * sizeof(float);
+
     default:
         Q_UNREACHABLE();
         return -1;
@@ -102,11 +112,22 @@ int byteSizeForMetaType(int type)
 UniformValue UniformValue::fromVariant(const QVariant &variant)
 {
     // Texture/Buffer case
-    if (variant.userType() == qNodeIdTypeId)
+    const int type = variant.userType();
+
+    if (type == qNodeIdTypeId)
         return UniformValue(variant.value<Qt3DCore::QNodeId>());
 
+    if (type == qMatrix4x4TypeId)
+        return UniformValue(variant.value<Matrix4x4>());
+
+    if (type == qVector3DTypeId)
+        return UniformValue(variant.value<Vector3D>());
+
+    if (type == qVector4DTypeId)
+        return UniformValue(variant.value<Vector4D>());
+
     UniformValue v;
-    switch (variant.userType()) {
+    switch (type) {
     case QMetaType::Bool:
         v.data<bool>()[0] = variant.toBool();
         break;
diff --git a/src/render/backend/uniform_p.h b/src/render/backend/uniform_p.h
index e0d8fedeb..213cf2606 100644
--- a/src/render/backend/uniform_p.h
+++ b/src/render/backend/uniform_p.h
@@ -53,6 +53,9 @@
 
 #include <qt3drender_global.h>
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
+#include <Qt3DCore/private/vector3d_p.h>
+#include <Qt3DCore/private/vector4d_p.h>
 
 #include <QMatrix4x4>
 #include <QVector2D>
@@ -135,8 +138,8 @@ public:
     UniformValue(double d) : UniformValue() { data<float>()[0] = d; } // Double to float conversion
     UniformValue(bool b) : UniformValue() { data<bool>()[0] = b; }
     UniformValue(const QVector2D &vec2) : UniformValue() { memcpy(m_data.data(), &vec2, sizeof(QVector2D)); }
-    UniformValue(const QVector3D &vec3) : UniformValue() { memcpy(m_data.data(), &vec3, sizeof(QVector3D)); }
-    UniformValue(const QVector4D &vec4) : m_data(4) { memcpy(m_data.data(), &vec4, sizeof(QVector4D)); }
+    UniformValue(const Vector3D &vec3) : UniformValue() { memcpy(m_data.data(), &vec3, sizeof(Vector3D)); }
+    UniformValue(const Vector4D &vec4) : m_data(sizeof(Vector4D) / sizeof(float)) { memcpy(m_data.data(), &vec4, sizeof(Vector4D)); }
 
     UniformValue(const QMatrix3x3 &mat33)
         : m_data(9)
@@ -145,12 +148,22 @@ public:
         memcpy(m_data.data(), mat33.constData(), 9 * sizeof(float));
     }
 
+    // We don t want the QMatrix4x4 builder to use sizeof since QMatrix4x4 contains a type flag
+#if defined(__SSE2__) || defined(__AVX2__)
+    UniformValue(const Matrix4x4 &mat44)
+        : m_data(sizeof(Matrix4x4) / sizeof(float))
+    {
+        // Use constData because we want column-major layout
+        memcpy(m_data.data(), &mat44, sizeof(Matrix4x4));
+    }
+#else
     UniformValue(const QMatrix4x4 &mat44)
         : m_data(16)
     {
         // Use constData because we want column-major layout
         memcpy(m_data.data(), mat44.constData(), 16 * sizeof(float));
     }
+#endif
 
     UniformValue(const QVector<QMatrix4x4> &v)
         : m_data(16 * v.size())
diff --git a/src/render/frontend/sphere.cpp b/src/render/frontend/sphere.cpp
index 2c22e0da4..740626163 100644
--- a/src/render/frontend/sphere.cpp
+++ b/src/render/frontend/sphere.cpp
@@ -53,18 +53,18 @@ namespace {
 
 // Intersects ray r = p + td, |d| = 1, with sphere s and, if intersecting,
 // returns true and intersection point q; false otherwise
-bool intersectRaySphere(const Qt3DRender::RayCasting::QRay3D &ray, const Qt3DRender::Render::Sphere &s, QVector3D *q = nullptr)
+bool intersectRaySphere(const Qt3DRender::RayCasting::QRay3D &ray, const Qt3DRender::Render::Sphere &s, Vector3D *q = nullptr)
 {
-    const QVector3D p = ray.origin();
-    const QVector3D d = ray.direction();
-    const QVector3D m = p - s.center();
-    const float c = QVector3D::dotProduct(m, m) - s.radius() * s.radius();
+    const Vector3D p = ray.origin();
+    const Vector3D d = ray.direction();
+    const Vector3D m = p - s.center();
+    const float c = Vector3D::dotProduct(m, m) - s.radius() * s.radius();
 
     // If there is definitely at least one real root, there must be an intersection
     if (q == nullptr && c <= 0.0f)
         return true;
 
-    const float b = QVector3D::dotProduct(m, d);
+    const float b = Vector3D::dotProduct(m, d);
     // Exit if r’s origin outside s (c > 0) and r pointing away from s (b > 0)
     if (c > 0.0f && b > 0.0f)
         return false;
@@ -89,12 +89,12 @@ bool intersectRaySphere(const Qt3DRender::RayCasting::QRay3D &ray, const Qt3DRen
     return true;
 }
 
-inline QPair<int, int> findExtremePoints(const QVector<QVector3D> &points)
+inline QPair<int, int> findExtremePoints(const QVector<Vector3D> &points)
 {
     // Find indices of extreme points along x, y, and z axes
     int xMin = 0, xMax = 0, yMin = 0, yMax = 0, zMin = 0, zMax = 0;
     for (int i = 1; i < points.size(); ++i) {
-        const QVector3D &p = points.at(i);
+        const Vector3D &p = points.at(i);
         if (p.x() < points[xMin].x())
             xMin = i;
         if (p.x() > points[xMax].x())
@@ -124,20 +124,20 @@ inline QPair<int, int> findExtremePoints(const QVector<QVector3D> &points)
     return extremeIndices;
 }
 
-inline void sphereFromExtremePoints(Qt3DRender::Render::Sphere &s, const QVector<QVector3D> &points)
+inline void sphereFromExtremePoints(Qt3DRender::Render::Sphere &s, const QVector<Vector3D> &points)
 {
     // Find two most separated points on any of the basis vectors
     QPair<int, int> extremeIndices = findExtremePoints(points);
 
     // Construct sphere to contain these two points
-    const QVector3D &p = points.at(extremeIndices.first);
-    const QVector3D &q = points.at(extremeIndices.second);
-    const QVector3D c = 0.5f * (p + q);
+    const Vector3D &p = points.at(extremeIndices.first);
+    const Vector3D &q = points.at(extremeIndices.second);
+    const Vector3D c = 0.5f * (p + q);
     s.setCenter(c);
     s.setRadius((q - c).length());
 }
 
-inline void constructRitterSphere(Qt3DRender::Render::Sphere &s, const QVector<QVector3D> &points)
+inline void constructRitterSphere(Qt3DRender::Render::Sphere &s, const QVector<Vector3D> &points)
 {
     // Calculate the sphere encompassing two axially extreme points
     sphereFromExtremePoints(s, points);
@@ -154,22 +154,22 @@ namespace Render {
 
 const float Sphere::ms_epsilon = 1.0e-7f;
 
-Sphere Sphere::fromPoints(const QVector<QVector3D> &points)
+Sphere Sphere::fromPoints(const QVector<Vector3D> &points)
 {
     Sphere s;
     s.initializeFromPoints(points);
     return s;
 }
 
-void Sphere::initializeFromPoints(const QVector<QVector3D> &points)
+void Sphere::initializeFromPoints(const QVector<Vector3D> &points)
 {
     if (!points.isEmpty())
         constructRitterSphere(*this, points);
 }
 
-void Sphere::expandToContain(const QVector3D &p)
+void Sphere::expandToContain(const Vector3D &p)
 {
-    const QVector3D d = p - m_center;
+    const Vector3D d = p - m_center;
     const float dist2 = d.lengthSquared();
 
     if (dist2 > m_radius * m_radius) {
@@ -184,7 +184,7 @@ void Sphere::expandToContain(const QVector3D &p)
 
 void Sphere::expandToContain(const Sphere &sphere)
 {
-    const QVector3D d(sphere.m_center - m_center);
+    const Vector3D d(sphere.m_center - m_center);
     const float dist2 = d.lengthSquared();
 
     const float dr = sphere.m_radius - m_radius;
@@ -204,16 +204,16 @@ void Sphere::expandToContain(const Sphere &sphere)
     }
 }
 
-Sphere Sphere::transformed(const QMatrix4x4 &mat) const
+Sphere Sphere::transformed(const Matrix4x4 &mat) const
 {
     // Transform extremities in x, y, and z directions to find extremities
     // of the resulting ellipsoid
-    QVector3D x = mat.map(m_center + QVector3D(m_radius, 0.0f, 0.0f));
-    QVector3D y = mat.map(m_center + QVector3D(0.0f, m_radius, 0.0f));
-    QVector3D z = mat.map(m_center + QVector3D(0.0f, 0.0f, m_radius));
+    Vector3D x = mat.map(m_center + Vector3D(m_radius, 0.0f, 0.0f));
+    Vector3D y = mat.map(m_center + Vector3D(0.0f, m_radius, 0.0f));
+    Vector3D z = mat.map(m_center + Vector3D(0.0f, 0.0f, m_radius));
 
     // Transform center and find maximum radius of ellipsoid
-    QVector3D c = mat.map(m_center);
+    Vector3D c = mat.map(m_center);
     float rSquared = qMax(qMax((x - c).lengthSquared(), (y - c).lengthSquared()), (z - c).lengthSquared());
     return Sphere(c, sqrt(rSquared), id());
 }
@@ -223,7 +223,7 @@ Qt3DCore::QNodeId Sphere::id() const
     return m_id;
 }
 
-bool Sphere::intersects(const RayCasting::QRay3D &ray, QVector3D *q, QVector3D *uvw) const
+bool Sphere::intersects(const RayCasting::QRay3D &ray, Vector3D *q, Vector3D *uvw) const
 {
     Q_UNUSED(uvw);
     return intersectRaySphere(ray, *this, q);
diff --git a/src/render/frontend/sphere_p.h b/src/render/frontend/sphere_p.h
index 1587aecab..ff6b2286b 100644
--- a/src/render/frontend/sphere_p.h
+++ b/src/render/frontend/sphere_p.h
@@ -53,10 +53,10 @@
 
 #include <Qt3DRender/private/qt3drender_global_p.h>
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
 #include <Qt3DRender/private/boundingsphere_p.h>
 
 #include <QMatrix4x4>
-#include <QVector3D>
 
 QT_BEGIN_NAMESPACE
 
@@ -73,58 +73,58 @@ public:
         , m_id(i)
     {}
 
-    inline Sphere(const QVector3D &c, float r, Qt3DCore::QNodeId i = Qt3DCore::QNodeId())
+    inline Sphere(const Vector3D &c, float r, Qt3DCore::QNodeId i = Qt3DCore::QNodeId())
         : m_center(c)
         , m_radius(r)
         , m_id(i)
     {}
 
-    void setCenter(const QVector3D &c);
-    QVector3D center() const Q_DECL_OVERRIDE;
+    void setCenter(const Vector3D &c);
+    Vector3D center() const Q_DECL_OVERRIDE;
 
-    inline bool isNull() { return m_center == QVector3D() && m_radius == 0.0f; }
+    inline bool isNull() { return m_center == Vector3D() && m_radius == 0.0f; }
 
     void setRadius(float r);
     float radius() const Q_DECL_OVERRIDE;
 
     void clear();
-    void initializeFromPoints(const QVector<QVector3D> &points);
-    void expandToContain(const QVector3D &point);
-    inline void expandToContain(const QVector<QVector3D> &points)
+    void initializeFromPoints(const QVector<Vector3D> &points);
+    void expandToContain(const Vector3D &point);
+    inline void expandToContain(const QVector<Vector3D> &points)
     {
-        for (const QVector3D &p : points)
+        for (const Vector3D &p : points)
             expandToContain(p);
     }
 
     void expandToContain(const Sphere &sphere);
 
-    Sphere transformed(const QMatrix4x4 &mat) const;
-    inline Sphere &transform(const QMatrix4x4 &mat)
+    Sphere transformed(const Matrix4x4 &mat) const;
+    inline Sphere &transform(const Matrix4x4 &mat)
     {
         *this = transformed(mat);
         return *this;
     }
 
     Qt3DCore::QNodeId id() const Q_DECL_FINAL;
-    bool intersects(const RayCasting::QRay3D &ray, QVector3D *q, QVector3D *uvw = nullptr) const Q_DECL_FINAL;
+    bool intersects(const RayCasting::QRay3D &ray, Vector3D *q, Vector3D *uvw = nullptr) const Q_DECL_FINAL;
     Type type() const Q_DECL_FINAL;
 
-    static Sphere fromPoints(const QVector<QVector3D> &points);
+    static Sphere fromPoints(const QVector<Vector3D> &points);
 
 private:
-    QVector3D m_center;
+    Vector3D m_center;
     float m_radius;
     Qt3DCore::QNodeId m_id;
 
     static const float ms_epsilon;
 };
 
-inline void Sphere::setCenter(const QVector3D &c)
+inline void Sphere::setCenter(const Vector3D &c)
 {
     m_center = c;
 }
 
-inline QVector3D Sphere::center() const
+inline Vector3D Sphere::center() const
 {
     return m_center;
 }
@@ -141,15 +141,15 @@ inline float Sphere::radius() const
 
 inline void Sphere::clear()
 {
-    m_center = QVector3D();
+    m_center = Vector3D();
     m_radius = 0.0f;
 }
 
 inline bool intersects(const Sphere &a, const Sphere &b)
 {
     // Calculate squared distance between sphere centers
-    const QVector3D d = a.center() - b.center();
-    const float distSq = QVector3D::dotProduct(d, d);
+    const Vector3D d = a.center() - b.center();
+    const float distSq = Vector3D::dotProduct(d, d);
 
     // Spheres intersect if squared distance is less than squared
     // sum of radii
diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp
index e81836502..7504b4ebd 100644
--- a/src/render/jobs/calcboundingvolumejob.cpp
+++ b/src/render/jobs/calcboundingvolumejob.cpp
@@ -93,8 +93,8 @@ public:
         const float zDist2 = (findExtremePoints.zMaxPt - findExtremePoints.zMinPt).lengthSquared();
 
         // Select most distant pair
-        QVector3D p = findExtremePoints.xMinPt;
-        QVector3D q = findExtremePoints.xMaxPt;
+        Vector3D p = findExtremePoints.xMinPt;
+        Vector3D q = findExtremePoints.xMaxPt;
         if (yDist2 > xDist2 && yDist2 > zDist2) {
             p = findExtremePoints.yMinPt;
             q = findExtremePoints.yMaxPt;
@@ -104,7 +104,7 @@ public:
             q = findExtremePoints.zMaxPt;
         }
 
-        const QVector3D c = 0.5f * (p + q);
+        const Vector3D c = 0.5f * (p + q);
         m_volume.setCenter(c);
         m_volume.setRadius((q - c).length());
 
@@ -128,40 +128,40 @@ private:
         { }
 
         float xMin, xMax, yMin, yMax, zMin, zMax;
-        QVector3D xMinPt, xMaxPt, yMinPt, yMaxPt, zMinPt, zMaxPt;
+        Vector3D xMinPt, xMaxPt, yMinPt, yMaxPt, zMinPt, zMaxPt;
 
         void visit(uint ndx, float x, float y, float z) override
         {
             if (ndx) {
                 if (x < xMin) {
                     xMin = x;
-                    xMinPt = QVector3D(x, y, z);
+                    xMinPt = Vector3D(x, y, z);
                 }
                 if (x > xMax) {
                     xMax = x;
-                    xMaxPt = QVector3D(x, y, z);
+                    xMaxPt = Vector3D(x, y, z);
                 }
                 if (y < yMin) {
                     yMin = y;
-                    yMinPt = QVector3D(x, y, z);
+                    yMinPt = Vector3D(x, y, z);
                 }
                 if (y > yMax) {
                     yMax = y;
-                    yMaxPt = QVector3D(x, y, z);
+                    yMaxPt = Vector3D(x, y, z);
                 }
                 if (z < zMin) {
                     zMin = z;
-                    zMinPt = QVector3D(x, y, z);
+                    zMinPt = Vector3D(x, y, z);
                 }
                 if (z > zMax) {
                     zMax = z;
-                    zMaxPt = QVector3D(x, y, z);
+                    zMaxPt = Vector3D(x, y, z);
                 }
             } else {
                 xMin = xMax = x;
                 yMin = yMax = y;
                 zMin = zMax = z;
-                xMinPt = xMaxPt = yMinPt = yMaxPt = zMinPt = zMaxPt = QVector3D(x, y, z);
+                xMinPt = xMaxPt = yMinPt = yMaxPt = zMinPt = zMaxPt = Vector3D(x, y, z);
             }
         }
     };
@@ -177,7 +177,7 @@ private:
         void visit(uint ndx, float x, float y, float z) override
         {
             Q_UNUSED(ndx);
-            m_volume.expandToContain(QVector3D(x, y, z));
+            m_volume.expandToContain(Vector3D(x, y, z));
         }
     };
 };
diff --git a/src/render/jobs/frustumcullingjob.cpp b/src/render/jobs/frustumcullingjob.cpp
index 85c6b5cad..1a03b691d 100644
--- a/src/render/jobs/frustumcullingjob.cpp
+++ b/src/render/jobs/frustumcullingjob.cpp
@@ -86,17 +86,17 @@ void FrustumCullingJob::cullScene(Entity *e, const Plane *planes)
     const Sphere *s = e->worldBoundingVolumeWithChildren();
 
     // Unrolled loop
-    if (QVector3D::dotProduct(s->center(), planes[0].normal) + planes[0].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[0].normal) + planes[0].d < -s->radius())
         return;
-    if (QVector3D::dotProduct(s->center(), planes[1].normal) + planes[1].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[1].normal) + planes[1].d < -s->radius())
         return;
-    if (QVector3D::dotProduct(s->center(), planes[2].normal) + planes[2].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[2].normal) + planes[2].d < -s->radius())
         return;
-    if (QVector3D::dotProduct(s->center(), planes[3].normal) + planes[3].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[3].normal) + planes[3].d < -s->radius())
         return;
-    if (QVector3D::dotProduct(s->center(), planes[4].normal) + planes[4].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[4].normal) + planes[4].d < -s->radius())
         return;
-    if (QVector3D::dotProduct(s->center(), planes[5].normal) + planes[5].d < -s->radius())
+    if (Vector3D::dotProduct(s->center(), planes[5].normal) + planes[5].d < -s->radius())
         return;
 
     m_visibleEntities.push_back(e);
diff --git a/src/render/jobs/frustumcullingjob_p.h b/src/render/jobs/frustumcullingjob_p.h
index ebd870937..4a5d8fd57 100644
--- a/src/render/jobs/frustumcullingjob_p.h
+++ b/src/render/jobs/frustumcullingjob_p.h
@@ -41,7 +41,8 @@
 #define QT3DRENDER_RENDER_FRUSTUMCULLINGJOB_P_H
 
 #include <Qt3DCore/qaspectjob.h>
-#include <QMatrix4x4>
+#include <Qt3DCore/private/matrix4x4_p.h>
+#include <Qt3DRender/private/aligned_malloc_p.h>
 
 //
 //  W A R N I N G
@@ -69,11 +70,13 @@ class FrustumCullingJob : public Qt3DCore::QAspectJob
 public:
     FrustumCullingJob();
 
+    QT3D_ALIGNED_MALLOC_AND_FREE()
+
     inline void setRoot(Entity *root) Q_DECL_NOTHROW { m_root = root; }
     inline void setActive(bool active) Q_DECL_NOTHROW { m_active = active; }
     inline bool isActive() const Q_DECL_NOTHROW { return m_active; }
-    inline void setViewProjection(const QMatrix4x4 &viewProjection) Q_DECL_NOTHROW { m_viewProjection = viewProjection; }
-    inline QMatrix4x4 viewProjection() const Q_DECL_NOTHROW { return m_viewProjection; }
+    inline void setViewProjection(const Matrix4x4 &viewProjection) Q_DECL_NOTHROW { m_viewProjection = viewProjection; }
+    inline Matrix4x4 viewProjection() const Q_DECL_NOTHROW { return m_viewProjection; }
 
     QVector<Entity *> visibleEntities() const Q_DECL_NOTHROW { return m_visibleEntities; }
 
@@ -81,7 +84,7 @@ public:
 
 private:
     void cullScene(Entity *e, const Plane *planes);
-    QMatrix4x4 m_viewProjection;
+    Matrix4x4 m_viewProjection;
     Entity *m_root;
     QVector<Entity *> m_visibleEntities;
     bool m_active;
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index ed6944d31..902c048e6 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -139,12 +139,12 @@ void PickBoundingVolumeJob::setRenderSettings(RenderSettings *settings)
     m_renderSettings = settings;
 }
 
-RayCasting::QRay3D PickBoundingVolumeJob::intersectionRay(const QPoint &pos, const QMatrix4x4 &viewMatrix,
-                                                          const QMatrix4x4 &projectionMatrix, const QRect &viewport)
+RayCasting::QRay3D PickBoundingVolumeJob::intersectionRay(const QPoint &pos, const Matrix4x4 &viewMatrix,
+                                                          const Matrix4x4 &projectionMatrix, const QRect &viewport)
 {
-    QVector3D nearPos = QVector3D(pos.x(), pos.y(), 0.0f);
+    Vector3D nearPos = Vector3D(pos.x(), pos.y(), 0.0f);
     nearPos = nearPos.unproject(viewMatrix, projectionMatrix, viewport);
-    QVector3D farPos = QVector3D(pos.x(), pos.y(), 1.0f);
+    Vector3D farPos = Vector3D(pos.x(), pos.y(), 1.0f);
     farPos = farPos.unproject(viewMatrix, projectionMatrix, viewport);
 
     return RayCasting::QRay3D(nearPos,
@@ -351,39 +351,48 @@ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent &event,
                 }
 
                 // Send the corresponding event
-                QVector3D localIntersection = hit.m_intersection;
+                Vector3D localIntersection = hit.m_intersection;
                 if (entity && entity->worldTransform())
                     localIntersection = entity->worldTransform()->inverted() * hit.m_intersection;
 
                 QPickEventPtr pickEvent;
                 switch (hit.m_type) {
                 case QCollisionQueryResult::Hit::Triangle:
-                    pickEvent = QPickTriangleEventPtr::create(event.localPos(), hit.m_intersection,
-                                                              localIntersection, hit.m_distance,
-                                                              hit.m_primitiveIndex,
-                                                              hit.m_vertexIndex[0],
-                                                              hit.m_vertexIndex[1],
-                                                              hit.m_vertexIndex[2],
-                                                              eventButton, eventButtons,
-                                                              eventModifiers, hit.m_uvw);
+                    pickEvent.reset(new QPickTriangleEvent(event.localPos(),
+                                                           convertToQVector3D(hit.m_intersection),
+                                                           convertToQVector3D(localIntersection),
+                                                           hit.m_distance,
+                                                           hit.m_primitiveIndex,
+                                                           hit.m_vertexIndex[0],
+                                                           hit.m_vertexIndex[1],
+                                                           hit.m_vertexIndex[2],
+                                                           eventButton, eventButtons,
+                                                           eventModifiers,
+                                                           convertToQVector3D(hit.m_uvw)));
                     break;
                 case QCollisionQueryResult::Hit::Edge:
-                    pickEvent = QPickLineEventPtr::create(event.localPos(), hit.m_intersection,
-                                                          localIntersection, hit.m_distance,
-                                                          hit.m_primitiveIndex,
-                                                          hit.m_vertexIndex[0], hit.m_vertexIndex[1],
-                                                          eventButton, eventButtons, eventModifiers);
+                    pickEvent.reset(new QPickLineEvent(event.localPos(),
+                                                       convertToQVector3D(hit.m_intersection),
+                                                       convertToQVector3D(localIntersection),
+                                                       hit.m_distance,
+                                                       hit.m_primitiveIndex,
+                                                       hit.m_vertexIndex[0], hit.m_vertexIndex[1],
+                                                       eventButton, eventButtons, eventModifiers));
                     break;
                 case QCollisionQueryResult::Hit::Point:
-                    pickEvent = QPickPointEventPtr::create(event.localPos(), hit.m_intersection,
-                                                           localIntersection, hit.m_distance,
-                                                           hit.m_vertexIndex[0],
-                                                           eventButton, eventButtons, eventModifiers);
+                    pickEvent.reset(new QPickPointEvent(event.localPos(),
+                                                        convertToQVector3D(hit.m_intersection),
+                                                        convertToQVector3D(localIntersection),
+                                                        hit.m_distance,
+                                                        hit.m_vertexIndex[0],
+                                                        eventButton, eventButtons, eventModifiers));
                     break;
                 case QCollisionQueryResult::Hit::Entity:
-                    pickEvent = QPickEventPtr::create(event.localPos(), hit.m_intersection,
-                                                      localIntersection, hit.m_distance,
-                                                      eventButton, eventButtons, eventModifiers);
+                    pickEvent.reset(new QPickEvent(event.localPos(),
+                                                   convertToQVector3D(hit.m_intersection),
+                                                   convertToQVector3D(localIntersection),
+                                                   hit.m_distance,
+                                                   eventButton, eventButtons, eventModifiers));
                     break;
                 default:
                     Q_UNREACHABLE();
@@ -461,6 +470,20 @@ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent &event,
     }
 }
 
+void PickBoundingVolumeJob::viewMatrixForCamera(Qt3DCore::QNodeId cameraId,
+                                                Matrix4x4 &viewMatrix,
+                                                Matrix4x4 &projectionMatrix) const
+{
+    Render::CameraLens *lens = nullptr;
+    Entity *camNode = m_manager->renderNodesManager()->lookupResource(cameraId);
+    if (camNode != nullptr &&
+            (lens = camNode->renderComponent<CameraLens>()) != nullptr &&
+            lens->isEnabled()) {
+        viewMatrix = *camNode->worldTransform();
+        projectionMatrix = lens->projection();
+    }
+}
+
 QRect PickBoundingVolumeJob::windowViewport(const QSize &area, const QRectF &relativeViewport) const
 {
     if (area.isValid()) {
@@ -479,9 +502,9 @@ RayCasting::QRay3D PickBoundingVolumeJob::rayForViewportAndCamera(const QSize &a
                                                                   const QRectF &relativeViewport,
                                                                   const Qt3DCore::QNodeId cameraId) const
 {
-    QMatrix4x4 viewMatrix;
-    QMatrix4x4 projectionMatrix;
-    Render::CameraLens::viewMatrixForCamera(m_manager->renderNodesManager(), cameraId, viewMatrix, projectionMatrix);
+    Matrix4x4 viewMatrix;
+    Matrix4x4 projectionMatrix;
+    viewMatrixForCamera(cameraId, viewMatrix, projectionMatrix);
     const QRect viewport = windowViewport(area, relativeViewport);
 
     // In GL the y is inverted compared to Qt
diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h
index d3f270d35..5d4f63f77 100644
--- a/src/render/jobs/pickboundingvolumejob_p.h
+++ b/src/render/jobs/pickboundingvolumejob_p.h
@@ -94,8 +94,8 @@ public:
     bool pickersDirty() const { return m_pickersDirty; }
 
     static RayCasting::QRay3D intersectionRay(const QPoint &pos,
-                                              const QMatrix4x4 &viewMatrix,
-                                              const QMatrix4x4 &projectionMatrix,
+                                              const Matrix4x4 &viewMatrix,
+                                              const Matrix4x4 &projectionMatrix,
                                               const QRect &viewport);
 
     // For unit tests
@@ -124,6 +124,9 @@ private:
 
     QList<QKeyEvent> m_pendingKeyEvents;
 
+    void viewMatrixForCamera(Qt3DCore::QNodeId cameraId,
+                             Matrix4x4 &viewMatrix,
+                             Matrix4x4 &projectionMatrix) const;
     QRect windowViewport(const QSize &area, const QRectF &relativeViewport) const;
     RayCasting::QRay3D rayForViewportAndCamera(const QSize &area,
                                                const QPoint &pos,
diff --git a/src/render/jobs/pickboundingvolumeutils.cpp b/src/render/jobs/pickboundingvolumeutils.cpp
index 564c1e86c..ae80b0a23 100644
--- a/src/render/jobs/pickboundingvolumeutils.cpp
+++ b/src/render/jobs/pickboundingvolumeutils.cpp
@@ -154,7 +154,6 @@ QVector<Entity *> EntityGatherer::entities() const
     return m_entities;
 }
 
-
 class TriangleCollisionVisitor : public TrianglesVisitor
 {
 public:
@@ -174,20 +173,20 @@ private:
     bool m_frontFaceRequested;
     bool m_backFaceRequested;
 
-    void visit(uint andx, const QVector3D &a,
-               uint bndx, const QVector3D &b,
-               uint cndx, const QVector3D &c) Q_DECL_OVERRIDE;
-    bool intersectsSegmentTriangle(uint andx, const QVector3D &a,
-                                   uint bndx, const QVector3D &b,
-                                   uint cndx, const QVector3D &c);
+    void visit(uint andx, const Vector3D &a,
+               uint bndx, const Vector3D &b,
+               uint cndx, const Vector3D &c) Q_DECL_OVERRIDE;
+    bool intersectsSegmentTriangle(uint andx, const Vector3D &a,
+                                   uint bndx, const Vector3D &b,
+                                   uint cndx, const Vector3D &c);
 };
 
-void TriangleCollisionVisitor::visit(uint andx, const QVector3D &a, uint bndx, const QVector3D &b, uint cndx, const QVector3D &c)
+void TriangleCollisionVisitor::visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
 {
-    const QMatrix4x4 &mat = *m_root->worldTransform();
-    const QVector3D tA = mat * a;
-    const QVector3D tB = mat * b;
-    const QVector3D tC = mat * c;
+    const Matrix4x4 &mat = *m_root->worldTransform();
+    const Vector3D tA = mat * a;
+    const Vector3D tB = mat * b;
+    const Vector3D tC = mat * c;
 
     bool intersected = m_frontFaceRequested &&
             intersectsSegmentTriangle(cndx, tC, bndx, tB, andx, tA);    // front facing
@@ -198,10 +197,11 @@ void TriangleCollisionVisitor::visit(uint andx, const QVector3D &a, uint bndx, c
     m_triangleIndex++;
 }
 
-bool TriangleCollisionVisitor::intersectsSegmentTriangle(uint andx, const QVector3D &a, uint bndx, const QVector3D &b, uint cndx, const QVector3D &c)
+
+bool TriangleCollisionVisitor::intersectsSegmentTriangle(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
 {
     float t = 0.0f;
-    QVector3D uvw;
+    Vector3D uvw;
     bool intersected = Render::intersectsSegmentTriangle(m_ray, a, b, c, uvw, t);
     if (intersected) {
         QCollisionQueryResult::Hit queryResult;
@@ -237,30 +237,30 @@ private:
     uint m_segmentIndex;
     float m_pickWorldSpaceTolerance;
 
-    void visit(uint andx, const QVector3D &a,
-               uint bndx, const QVector3D &b) Q_DECL_OVERRIDE;
-    bool intersectsSegmentSegment(uint andx, const QVector3D &a,
-                                  uint bndx, const QVector3D &b);
-    bool rayToLineSegment(const QVector3D& lineStart,const QVector3D& lineEnd,
-                          float &distance, QVector3D &intersection) const;
+    void visit(uint andx, const Vector3D &a,
+               uint bndx, const Vector3D &b) Q_DECL_OVERRIDE;
+    bool intersectsSegmentSegment(uint andx, const Vector3D &a,
+                                  uint bndx, const Vector3D &b);
+    bool rayToLineSegment(const Vector3D& lineStart,const Vector3D& lineEnd,
+                          float &distance, Vector3D &intersection) const;
 };
 
-void LineCollisionVisitor::visit(uint andx, const QVector3D &a, uint bndx, const QVector3D &b)
+void LineCollisionVisitor::visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b)
 {
-    const QMatrix4x4 &mat = *m_root->worldTransform();
-    const QVector3D tA = mat * a;
-    const QVector3D tB = mat * b;
+    const Matrix4x4 &mat = *m_root->worldTransform();
+    const Vector3D tA = mat * a;
+    const Vector3D tB = mat * b;
 
     intersectsSegmentSegment(andx, tA, bndx, tB);
 
     m_segmentIndex++;
 }
 
-bool LineCollisionVisitor::intersectsSegmentSegment(uint andx, const QVector3D &a,
-                                                    uint bndx, const QVector3D &b)
+bool LineCollisionVisitor::intersectsSegmentSegment(uint andx, const Vector3D &a,
+                                                    uint bndx, const Vector3D &b)
 {
     float distance = 0.f;
-    QVector3D intersection;
+    Vector3D intersection;
     bool res = rayToLineSegment(a, b, distance, intersection);
     if (res) {
         QCollisionQueryResult::Hit queryResult;
@@ -277,19 +277,19 @@ bool LineCollisionVisitor::intersectsSegmentSegment(uint andx, const QVector3D &
     return false;
 }
 
-bool LineCollisionVisitor::rayToLineSegment(const QVector3D& lineStart,const QVector3D& lineEnd,
-                                            float &distance, QVector3D &intersection) const
+bool LineCollisionVisitor::rayToLineSegment(const Vector3D& lineStart,const Vector3D& lineEnd,
+                                            float &distance, Vector3D &intersection) const
 {
     const float epsilon = 0.00000001f;
 
-    const QVector3D u = m_ray.direction() * m_ray.distance();
-    const QVector3D v = lineEnd - lineStart;
-    const QVector3D w = m_ray.origin() - lineStart;
-    const float a = QVector3D::dotProduct(u, u);
-    const float b = QVector3D::dotProduct(u, v);
-    const float c = QVector3D::dotProduct(v, v);
-    const float d = QVector3D::dotProduct(u, w);
-    const float e = QVector3D::dotProduct(v, w);
+    const Vector3D u = m_ray.direction() * m_ray.distance();
+    const Vector3D v = lineEnd - lineStart;
+    const Vector3D w = m_ray.origin() - lineStart;
+    const float a = Vector3D::dotProduct(u, u);
+    const float b = Vector3D::dotProduct(u, v);
+    const float c = Vector3D::dotProduct(v, v);
+    const float d = Vector3D::dotProduct(u, w);
+    const float e = Vector3D::dotProduct(v, w);
     const float D = a * c - b * b;
     float sc, sN, sD = D;
     float tc, tN, tD = D;
@@ -330,7 +330,7 @@ bool LineCollisionVisitor::rayToLineSegment(const QVector3D& lineStart,const QVe
     sc = (qAbs(sN) < epsilon ? 0.0f : sN / sD);
     tc = (qAbs(tN) < epsilon ? 0.0f : tN / tD);
 
-    const QVector3D dP = w + (sc * u) - (tc * v);
+    const Vector3D dP = w + (sc * u) - (tc * v);
     const float f = dP.length();
     if (f < m_pickWorldSpaceTolerance) {
         distance = sc * u.length();
@@ -358,23 +358,23 @@ private:
     uint m_pointIndex;
     float m_pickWorldSpaceTolerance;
 
-    void visit(uint ndx, const QVector3D &p) Q_DECL_OVERRIDE;
+    void visit(uint ndx, const Vector3D &p) Q_DECL_OVERRIDE;
 
-    double pointToRayDistance(const QVector3D &a, QVector3D &p)
+    double pointToRayDistance(const Vector3D &a, Vector3D &p)
     {
-        const QVector3D v = a - m_ray.origin();
-        const double t = QVector3D::dotProduct(v, m_ray.direction());
+        const Vector3D v = a - m_ray.origin();
+        const double t = Vector3D::dotProduct(v, m_ray.direction());
         p = m_ray.origin() + t * m_ray.direction();
         return (p - a).length();
     }
 };
 
 
-void PointCollisionVisitor::visit(uint ndx, const QVector3D &p)
+void PointCollisionVisitor::visit(uint ndx, const Vector3D &p)
 {
-    const QMatrix4x4 &mat = *m_root->worldTransform();
-    const QVector3D tP = mat * p;
-    QVector3D intersection;
+    const Matrix4x4 &mat = *m_root->worldTransform();
+    const Vector3D tP = mat * p;
+    Vector3D intersection;
 
     float d = pointToRayDistance(tP, intersection);
     if (d < m_pickWorldSpaceTolerance) {
@@ -461,10 +461,32 @@ void AbstractCollisionGathererFunctor::sortHits(HitList &results)
     std::sort(results.begin(), results.end(), compareHitsDistance);
 }
 
+namespace {
+
+// Workaround to avoid passing *this into the blockMappedReduce calls for the
+// mapFunctor which would cause an SSE alignment error on Windows Also note
+// that a lambda doesn't work since we need the typedef result_type defined to
+// work with QtConcurrent
+struct MapFunctorHolder
+{
+    MapFunctorHolder(const AbstractCollisionGathererFunctor *gatherer)
+        : m_gatherer(gatherer)
+    {}
+
+    // This define is required to work with QtConcurrent
+    typedef HitList result_type;
+    HitList operator ()(const Entity *e) const { return m_gatherer->operator ()(e); }
+
+    const AbstractCollisionGathererFunctor *m_gatherer;
+};
+
+} // anonymous
+
 HitList EntityCollisionGathererFunctor::computeHits(const QVector<Entity *> &entities, bool allHitsRequested)
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
-    return QtConcurrent::blockingMappedReduced<HitList>(entities, *this, reducerOp);
+    const MapFunctorHolder holder(this);
+    return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
 }
 
 HitList EntityCollisionGathererFunctor::pick(const Entity *entity) const
@@ -482,7 +504,8 @@ HitList EntityCollisionGathererFunctor::pick(const Entity *entity) const
 HitList TriangleCollisionGathererFunctor::computeHits(const QVector<Entity *> &entities, bool allHitsRequested)
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
-    return QtConcurrent::blockingMappedReduced<HitList>(entities, *this, reducerOp);
+    const MapFunctorHolder holder(this);
+    return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
 }
 
 HitList TriangleCollisionGathererFunctor::pick(const Entity *entity) const
@@ -507,7 +530,8 @@ HitList TriangleCollisionGathererFunctor::pick(const Entity *entity) const
 HitList LineCollisionGathererFunctor::computeHits(const QVector<Entity *> &entities, bool allHitsRequested)
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
-    return QtConcurrent::blockingMappedReduced<HitList>(entities, *this, reducerOp);
+    const MapFunctorHolder holder(this);
+    return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
 }
 
 HitList LineCollisionGathererFunctor::pick(const Entity *entity) const
@@ -531,7 +555,8 @@ HitList LineCollisionGathererFunctor::pick(const Entity *entity) const
 HitList PointCollisionGathererFunctor::computeHits(const QVector<Entity *> &entities, bool allHitsRequested)
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
-    return QtConcurrent::blockingMappedReduced<HitList>(entities, *this, reducerOp);
+    const MapFunctorHolder holder(this);
+    return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
 }
 
 HitList PointCollisionGathererFunctor::pick(const Entity *entity) const
diff --git a/src/render/jobs/renderviewjobutils_p.h b/src/render/jobs/renderviewjobutils_p.h
index c1d37b28a..542b797d0 100644
--- a/src/render/jobs/renderviewjobutils_p.h
+++ b/src/render/jobs/renderviewjobutils_p.h
@@ -57,6 +57,7 @@
 #include <QtCore/qvariant.h>
 #include <QMatrix4x4>
 #include <Qt3DRender/private/uniform_p.h>
+#include <Qt3DRender/private/aligned_malloc_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -158,6 +159,8 @@ struct Q_AUTOTEST_EXPORT UniformBlockValueBuilder
     UniformBlockValueBuilder();
     ~UniformBlockValueBuilder();
 
+    QT3D_ALIGNED_MALLOC_AND_FREE()
+
     void buildActiveUniformNameValueMapHelper(ShaderData *currentShaderData,
                                               const QString &blockName,
                                               const QString &qmlPropertyName,
@@ -171,7 +174,7 @@ struct Q_AUTOTEST_EXPORT UniformBlockValueBuilder
     UniformBlockValueBuilderHash activeUniformNamesToValue;
     ShaderDataManager *shaderDataManager;
     TextureManager *textureManager;
-    QMatrix4x4 viewMatrix;
+    Matrix4x4 viewMatrix;
 };
 
 } // namespace Render
diff --git a/src/render/jobs/updatelevelofdetailjob.cpp b/src/render/jobs/updatelevelofdetailjob.cpp
index 8b604229a..ad9bee8e1 100644
--- a/src/render/jobs/updatelevelofdetailjob.cpp
+++ b/src/render/jobs/updatelevelofdetailjob.cpp
@@ -140,20 +140,20 @@ void UpdateLevelOfDetailJob::updateEntityLod(Entity *entity)
 
 void UpdateLevelOfDetailJob::updateEntityLodByDistance(Entity *entity, LevelOfDetail *lod)
 {
-    QMatrix4x4 viewMatrix;
-    QMatrix4x4 projectionMatrix;
+    Matrix4x4 viewMatrix;
+    Matrix4x4 projectionMatrix;
     if (!Render::CameraLens::viewMatrixForCamera(m_manager->renderNodesManager(), lod->camera(), viewMatrix, projectionMatrix))
         return;
 
     const QVector<qreal> thresholds = lod->thresholds();
-    QVector3D center = lod->center();
+    Vector3D center(lod->center());
     if (lod->hasBoundingVolumeOverride() || entity->worldBoundingVolume() == nullptr) {
         center = *entity->worldTransform() * center;
     } else {
         center = entity->worldBoundingVolume()->center();
     }
 
-    const QVector3D tcenter = viewMatrix * center;
+    const Vector3D tcenter = viewMatrix * center;
     const float dist = tcenter.length();
     const int n = thresholds.size();
     for (int i=0; i<n; ++i) {
@@ -169,8 +169,8 @@ void UpdateLevelOfDetailJob::updateEntityLodByDistance(Entity *entity, LevelOfDe
 
 void UpdateLevelOfDetailJob::updateEntityLodByScreenArea(Entity *entity, LevelOfDetail *lod)
 {
-    QMatrix4x4 viewMatrix;
-    QMatrix4x4 projectionMatrix;
+    Matrix4x4 viewMatrix;
+    Matrix4x4 projectionMatrix;
     if (!Render::CameraLens::viewMatrixForCamera(m_manager->renderNodesManager(), lod->camera(), viewMatrix, projectionMatrix))
         return;
 
@@ -182,7 +182,7 @@ void UpdateLevelOfDetailJob::updateEntityLodByScreenArea(Entity *entity, LevelOf
     const PickingUtils::ViewportCameraAreaTriplet &vca = vcaTriplets.front();
 
     const QVector<qreal> thresholds = lod->thresholds();
-    Sphere bv(lod->center(), lod->radius());
+    Sphere bv(Vector3D(lod->center()), lod->radius());
     if (!lod->hasBoundingVolumeOverride() && entity->worldBoundingVolume() != nullptr) {
         bv = *(entity->worldBoundingVolume());
     } else {
diff --git a/src/render/jobs/updatelevelofdetailjob_p.h b/src/render/jobs/updatelevelofdetailjob_p.h
index c29501a09..71c7d003d 100644
--- a/src/render/jobs/updatelevelofdetailjob_p.h
+++ b/src/render/jobs/updatelevelofdetailjob_p.h
@@ -84,6 +84,7 @@ private:
     void updateEntityLod(Entity *entity);
     void updateEntityLodByDistance(Entity *entity, LevelOfDetail *lod);
     void updateEntityLodByScreenArea(Entity *entity, LevelOfDetail *lod);
+
     QRect windowViewport(const QSize &area, const QRectF &relativeViewport) const;
 
     NodeManagers *m_manager;
diff --git a/src/render/jobs/updateworldtransformjob.cpp b/src/render/jobs/updateworldtransformjob.cpp
index 8b11cd309..c56ed8507 100644
--- a/src/render/jobs/updateworldtransformjob.cpp
+++ b/src/render/jobs/updateworldtransformjob.cpp
@@ -54,9 +54,9 @@ namespace Render {
 
 namespace {
 
-void updateWorldTransformAndBounds(Qt3DRender::Render::Entity *node, const QMatrix4x4 &parentTransform)
+void updateWorldTransformAndBounds(Qt3DRender::Render::Entity *node, const Matrix4x4 &parentTransform)
 {
-    QMatrix4x4 worldTransform(parentTransform);
+    Matrix4x4 worldTransform(parentTransform);
     Transform *nodeTransform = node->renderComponent<Transform>();
 
     if (nodeTransform != nullptr && nodeTransform->isEnabled())
@@ -94,7 +94,7 @@ void UpdateWorldTransformJob::run()
 
     qCDebug(Jobs) << "Entering" << Q_FUNC_INFO << QThread::currentThread();
 
-    QMatrix4x4 parentTransform;
+    Matrix4x4 parentTransform;
     Entity *parent = m_node->parent();
     if (parent != nullptr)
         parentTransform = *(parent->worldTransform());
diff --git a/src/render/materialsystem/shaderdata.cpp b/src/render/materialsystem/shaderdata.cpp
index fec1e66ac..de423c3c2 100644
--- a/src/render/materialsystem/shaderdata.cpp
+++ b/src/render/materialsystem/shaderdata.cpp
@@ -171,7 +171,7 @@ void ShaderData::cleanup(NodeManagers *managers)
     m_updatedShaderData.clear();
 }
 
-QVariant ShaderData::getTransformedProperty(const QString &name, const QMatrix4x4 &viewMatrix)
+QVariant ShaderData::getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix)
 {
     // Note protecting m_worldMatrix at this point as we assume all world updates
     // have been performed when reaching this point
@@ -180,11 +180,11 @@ QVariant ShaderData::getTransformedProperty(const QString &name, const QMatrix4x
         const TransformType transformType = it.value();
         switch (transformType) {
         case ModelToEye:
-            return QVariant::fromValue(viewMatrix * m_worldMatrix * m_originalProperties.value(name).value<QVector3D>());
+            return QVariant::fromValue(viewMatrix * m_worldMatrix * Vector3D(m_originalProperties.value(name).value<QVector3D>()));
         case ModelToWorld:
-            return QVariant::fromValue(m_worldMatrix * m_originalProperties.value(it.key()).value<QVector3D>());
+            return QVariant::fromValue(m_worldMatrix * Vector3D(m_originalProperties.value(it.key()).value<QVector3D>()));
         case ModelToWorldDirection:
-            return QVariant::fromValue((m_worldMatrix * QVector4D(m_originalProperties.value(it.key()).value<QVector3D>(), 0.0f)).toVector3D());
+            return QVariant::fromValue(Vector3D(m_worldMatrix * Vector4D(m_originalProperties.value(it.key()).value<QVector3D>(), 0.0f)));
         case NoTransform:
             break;
         }
@@ -193,7 +193,7 @@ QVariant ShaderData::getTransformedProperty(const QString &name, const QMatrix4x
 }
 
 // Called by FramePreparationJob or by RenderView when dealing with lights
-void ShaderData::updateWorldTransform(const QMatrix4x4 &worldMatrix)
+void ShaderData::updateWorldTransform(const Matrix4x4 &worldMatrix)
 {
     QMutexLocker lock(&m_mutex);
     if (m_worldMatrix != worldMatrix) {
diff --git a/src/render/materialsystem/shaderdata_p.h b/src/render/materialsystem/shaderdata_p.h
index 987687eab..5951af53c 100644
--- a/src/render/materialsystem/shaderdata_p.h
+++ b/src/render/materialsystem/shaderdata_p.h
@@ -55,7 +55,7 @@
 #include <Qt3DRender/private/shadervariables_p.h>
 #include <Qt3DRender/qshaderdata.h>
 #include <QMutex>
-#include <QMatrix4x4>
+#include <Qt3DCore/private/matrix4x4_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -83,13 +83,13 @@ public:
     QHash<QString, QVariant> properties() const { return m_originalProperties; }
 
     // Called by FramePreparationJob
-    void updateWorldTransform(const QMatrix4x4 &worldMatrix);
+    void updateWorldTransform(const Matrix4x4 &worldMatrix);
 
     // Call by RenderViewJob
     void markDirty();
 
     TransformType propertyTransformType(const QString &name) const;
-    QVariant getTransformedProperty(const QString &name, const QMatrix4x4 &viewMatrix);
+    QVariant getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix);
 
     // Called by FrameCleanupJob
     static void cleanup(NodeManagers *managers);
@@ -114,8 +114,8 @@ protected:
 
     QMutex m_mutex;
     static QVector<Qt3DCore::QNodeId> m_updatedShaderData;
-    QMatrix4x4 m_worldMatrix;
-    QMatrix4x4 m_viewMatrix;
+    Matrix4x4 m_worldMatrix;
+    Matrix4x4 m_viewMatrix;
     NodeManagers *m_managers;
 
     void clearUpdatedProperties();
diff --git a/src/render/raycasting/boundingsphere_p.h b/src/render/raycasting/boundingsphere_p.h
index 63bd8a562..bcffbaa19 100644
--- a/src/render/raycasting/boundingsphere_p.h
+++ b/src/render/raycasting/boundingsphere_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DRender/private/qboundingvolume_p.h>
+#include <Qt3DCore/private/vector3d_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -65,7 +66,7 @@ public:
     BoundingSphere();
     ~BoundingSphere();
 
-    virtual QVector3D center() const = 0;
+    virtual Vector3D center() const = 0;
     virtual float radius() const = 0;
 };
 
diff --git a/src/render/raycasting/qabstractcollisionqueryservice.cpp b/src/render/raycasting/qabstractcollisionqueryservice.cpp
index 993ad840e..5148df911 100644
--- a/src/render/raycasting/qabstractcollisionqueryservice.cpp
+++ b/src/render/raycasting/qabstractcollisionqueryservice.cpp
@@ -62,8 +62,8 @@ void QAbstractCollisionQueryService::setResultHandle(QCollisionQueryResult &resu
 }
 
 void QAbstractCollisionQueryService::addEntityHit(QCollisionQueryResult &result, Qt3DCore::QNodeId entity,
-                                                  const QVector3D& intersection, float distance,
-                                                  const QVector3D& uvw)
+                                                  const Vector3D& intersection, float distance,
+                                                  const Vector3D& uvw)
 {
     result.d_func()->addEntityHit(entity, intersection, distance, uvw);
 }
diff --git a/src/render/raycasting/qabstractcollisionqueryservice_p.h b/src/render/raycasting/qabstractcollisionqueryservice_p.h
index 1c1261937..fa35792d0 100644
--- a/src/render/raycasting/qabstractcollisionqueryservice_p.h
+++ b/src/render/raycasting/qabstractcollisionqueryservice_p.h
@@ -97,8 +97,8 @@ protected:
     QAbstractCollisionQueryService(QAbstractCollisionQueryServicePrivate &dd);
 
     void setResultHandle(QCollisionQueryResult &result, const QQueryHandle &handle);
-    void addEntityHit(QCollisionQueryResult &result, Qt3DCore::QNodeId entity, const QVector3D &intersection,
-                      float distance, const QVector3D &uvw);
+    void addEntityHit(QCollisionQueryResult &result, Qt3DCore::QNodeId entity, const Vector3D &intersection,
+                      float distance, const Vector3D &uvw);
 
 private:
     Q_DECLARE_PRIVATE(QAbstractCollisionQueryService)
diff --git a/src/render/raycasting/qboundingvolume_p.h b/src/render/raycasting/qboundingvolume_p.h
index 8267c2b18..b63463f23 100644
--- a/src/render/raycasting/qboundingvolume_p.h
+++ b/src/render/raycasting/qboundingvolume_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/vector3d_p.h>
 
 QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
@@ -72,8 +73,8 @@ public:
     };
 
     virtual Qt3DCore::QNodeId id() const = 0;
-    virtual bool intersects(const QRay3D &ray, QVector3D *q = nullptr,
-                            QVector3D *uvw = nullptr) const = 0;
+    virtual bool intersects(const QRay3D &ray, Vector3D *q = nullptr,
+                            Vector3D *uvw = nullptr) const = 0;
 
     virtual Type type() const = 0;
 };
diff --git a/src/render/raycasting/qcollisionqueryresult.cpp b/src/render/raycasting/qcollisionqueryresult.cpp
index 62975200c..9d1e484b6 100644
--- a/src/render/raycasting/qcollisionqueryresult.cpp
+++ b/src/render/raycasting/qcollisionqueryresult.cpp
@@ -56,8 +56,8 @@ QCollisionQueryResultPrivate::QCollisionQueryResultPrivate(const QCollisionQuery
 {
 }
 
-void QCollisionQueryResultPrivate::addEntityHit(Qt3DCore::QNodeId entity, const QVector3D& intersection,
-                                                float distance, const QVector3D& uvw)
+void QCollisionQueryResultPrivate::addEntityHit(Qt3DCore::QNodeId entity, const Vector3D& intersection,
+                                                float distance, const Vector3D& uvw)
 {
     m_hits.append(QCollisionQueryResult::Hit(entity, intersection, distance, uvw));
 }
diff --git a/src/render/raycasting/qcollisionqueryresult_p.h b/src/render/raycasting/qcollisionqueryresult_p.h
index 1a430e019..24371d30e 100644
--- a/src/render/raycasting/qcollisionqueryresult_p.h
+++ b/src/render/raycasting/qcollisionqueryresult_p.h
@@ -53,8 +53,8 @@
 
 #include <Qt3DRender/qt3drender_global.h>
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DCore/private/vector3d_p.h>
 #include <QVector>
-#include <QVector3D>
 #include <QSharedData>
 
 QT_BEGIN_NAMESPACE
@@ -84,7 +84,7 @@ public:
             m_vertexIndex[0] = m_vertexIndex[1] = m_vertexIndex[2] = 0;
         }
 
-        Hit(Qt3DCore::QNodeId entity, const QVector3D &intersection, float distance, const QVector3D &uvw)
+        Hit(Qt3DCore::QNodeId entity, const Vector3D &intersection, float distance, const Vector3D &uvw)
             : m_entityId(entity)
             , m_intersection(intersection)
             , m_distance(distance)
@@ -94,11 +94,11 @@ public:
 
         Qt3DCore::QNodeId m_entityId;
         HitType m_type;
-        QVector3D m_intersection;
+        Vector3D m_intersection;
         float m_distance;
         uint m_primitiveIndex;
         uint m_vertexIndex[3];
-        QVector3D m_uvw;
+        Vector3D m_uvw;
     };
 
     QCollisionQueryResult();
@@ -146,8 +146,8 @@ public:
     explicit QCollisionQueryResultPrivate(const QCollisionQueryResultPrivate &copy);
 
     void setHandle(const QQueryHandle &handle);
-    void addEntityHit(Qt3DCore::QNodeId entity, const QVector3D& intersection, float distance,
-                      const QVector3D& uvw);
+    void addEntityHit(Qt3DCore::QNodeId entity, const Vector3D& intersection, float distance,
+                      const Vector3D& uvw);
 
     QQueryHandle m_handle;
     QVector<QCollisionQueryResult::Hit> m_hits;
diff --git a/src/render/raycasting/qray3d.cpp b/src/render/raycasting/qray3d.cpp
index 3f136deb8..40d16bc73 100644
--- a/src/render/raycasting/qray3d.cpp
+++ b/src/render/raycasting/qray3d.cpp
@@ -93,7 +93,7 @@ QRay3D::QRay3D()
     QRay3D thruAB(pointA, pointB - pointA);
     \endcode
 */
-QRay3D::QRay3D(const QVector3D &origin, const QVector3D &direction, float distance)
+QRay3D::QRay3D(const Vector3D &origin, const Vector3D &direction, float distance)
     : m_origin(origin)
     , m_direction(direction)
     , m_distance(distance)
@@ -110,7 +110,7 @@ QRay3D::~QRay3D()
 
     \sa setOrigin(), direction()
 */
-QVector3D QRay3D::origin() const
+Vector3D QRay3D::origin() const
 {
     return m_origin;
 }
@@ -122,7 +122,7 @@ QVector3D QRay3D::origin() const
 
     \sa origin(), setDirection()
  */
-void QRay3D::setOrigin(const QVector3D &value)
+void QRay3D::setOrigin(const Vector3D &value)
 {
     m_origin = value;
 }
@@ -134,7 +134,7 @@ void QRay3D::setOrigin(const QVector3D &value)
 
     \sa setDirection(), origin()
 */
-QVector3D QRay3D::direction() const
+Vector3D QRay3D::direction() const
 {
     return m_direction;
 }
@@ -146,7 +146,7 @@ QVector3D QRay3D::direction() const
 
     \sa direction(), setOrigin()
 */
-void QRay3D::setDirection(const QVector3D &value)
+void QRay3D::setDirection(const Vector3D &value)
 {
     if (value.isNull())
         return;
@@ -164,12 +164,12 @@ void QRay3D::setDistance(float distance)
     m_distance = distance;
 }
 
-QVector3D QRay3D::point(float t) const
+Vector3D QRay3D::point(float t) const
 {
     return m_origin + t * m_direction;
 }
 
-QRay3D &QRay3D::transform(const QMatrix4x4 &matrix)
+QRay3D &QRay3D::transform(const Matrix4x4 &matrix)
 {
     m_origin = matrix * m_origin;
     m_direction = matrix.mapVector(m_direction);
@@ -177,7 +177,7 @@ QRay3D &QRay3D::transform(const QMatrix4x4 &matrix)
     return *this;
 }
 
-QRay3D QRay3D::transformed(const QMatrix4x4 &matrix) const
+QRay3D QRay3D::transformed(const Matrix4x4 &matrix) const
 {
     return QRay3D(matrix * m_origin, matrix.mapVector(m_direction));
 }
@@ -195,12 +195,12 @@ bool QRay3D::operator!=(const QRay3D &other) const
 /*!
     Returns true if \a point lies on this ray; false otherwise.
 */
-bool QRay3D::contains(const QVector3D &point) const
+bool QRay3D::contains(const Vector3D &point) const
 {
-    QVector3D ppVec(point - m_origin);
+    Vector3D  ppVec(point - m_origin);
     if (ppVec.isNull()) // point coincides with origin
         return true;
-    const float dot = QVector3D::dotProduct(ppVec, m_direction);
+    const float dot = Vector3D ::dotProduct(ppVec, m_direction);
     if (qFuzzyIsNull(dot))
         return false;
     return qFuzzyCompare(dot*dot, ppVec.lengthSquared() * m_direction.lengthSquared());
@@ -213,7 +213,7 @@ bool QRay3D::contains(const QVector3D &point) const
 */
 bool QRay3D::contains(const QRay3D &ray) const
 {
-    const float dot = QVector3D::dotProduct(m_direction, ray.direction());
+    const float dot = Vector3D ::dotProduct(m_direction, ray.direction());
     if (!qFuzzyCompare(dot*dot, m_direction.lengthSquared() * ray.direction().lengthSquared()))
         return false;
     return contains(ray.origin());
@@ -247,11 +247,11 @@ bool QRay3D::contains(const QRay3D &ray) const
 
     \sa point(), project()
 */
-float QRay3D::projectedDistance(const QVector3D &point) const
+float QRay3D::projectedDistance(const Vector3D  &point) const
 {
     Q_ASSERT(!m_direction.isNull());
 
-    return QVector3D::dotProduct(point - m_origin, m_direction) /
+    return Vector3D ::dotProduct(point - m_origin, m_direction) /
                 m_direction.lengthSquared();
 }
 
@@ -264,10 +264,10 @@ float QRay3D::projectedDistance(const QVector3D &point) const
 
     \sa projectedDistance()
 */
-QVector3D QRay3D::project(const QVector3D &vector) const
+Vector3D  QRay3D::project(const Vector3D &vector) const
 {
-    QVector3D norm = m_direction.normalized();
-    return QVector3D::dotProduct(vector, norm) * norm;
+    Vector3D  norm = m_direction.normalized();
+    return Vector3D ::dotProduct(vector, norm) * norm;
 }
 
 /*!
@@ -277,7 +277,7 @@ QVector3D QRay3D::project(const QVector3D &vector) const
 
     \sa point()
 */
-float QRay3D::distance(const QVector3D &point) const
+float QRay3D::distance(const Vector3D  &point) const
 {
     float t = projectedDistance(point);
     return (point - (m_origin + t * m_direction)).length();
@@ -350,8 +350,8 @@ QDebug operator<<(QDebug dbg, const QRay3D &ray)
 */
 QDataStream &operator<<(QDataStream &stream, const QRay3D &ray)
 {
-    stream << ray.origin();
-    stream << ray.direction();
+    stream << convertToQVector3D(ray.origin());
+    stream << convertToQVector3D(ray.direction());
     return stream;
 }
 
@@ -364,9 +364,10 @@ QDataStream &operator<<(QDataStream &stream, const QRay3D &ray)
 QDataStream &operator>>(QDataStream &stream, QRay3D &ray)
 {
     QVector3D origin, direction;
+
     stream >> origin;
     stream >> direction;
-    ray = QRay3D(origin, direction);
+    ray = QRay3D(Vector3D(origin), Vector3D(direction));
     return stream;
 }
 
diff --git a/src/render/raycasting/qray3d_p.h b/src/render/raycasting/qray3d_p.h
index 7c1156b76..c5e2be078 100644
--- a/src/render/raycasting/qray3d_p.h
+++ b/src/render/raycasting/qray3d_p.h
@@ -53,8 +53,8 @@
 //
 
 #include <Qt3DRender/qt3drender_global.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qmatrix4x4.h>
+#include <Qt3DCore/private/matrix4x4_p.h>
+#include <Qt3DCore/private/vector3d_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -65,37 +65,37 @@ class QT3DRENDERSHARED_EXPORT QRay3D
 {
 public:
     QRay3D();
-    explicit QRay3D(const QVector3D &origin, const QVector3D &direction = QVector3D(0.0f, 0.0f, 1.0f), float distance = 1.0f);
+    explicit QRay3D(const Vector3D &origin, const Vector3D &direction = Vector3D(0.0f, 0.0f, 1.0f), float distance = 1.0f);
     ~QRay3D();
 
-    QVector3D origin() const;
-    void setOrigin(const QVector3D &value);
+    Vector3D origin() const;
+    void setOrigin(const Vector3D &value);
 
-    QVector3D direction() const;
-    void setDirection(const QVector3D &value);
+    Vector3D direction() const;
+    void setDirection(const Vector3D &value);
 
     float distance() const;
     void setDistance(float distance);
 
-    bool contains(const QVector3D &point) const;
+    bool contains(const Vector3D &point) const;
     bool contains(const QRay3D &ray) const;
 
-    QVector3D point(float t) const;
-    float projectedDistance(const QVector3D &point) const;
+    Vector3D point(float t) const;
+    float projectedDistance(const Vector3D &point) const;
 
-    QVector3D project(const QVector3D &vector) const;
+    Vector3D project(const Vector3D &vector) const;
 
-    float distance(const QVector3D &point) const;
+    float distance(const Vector3D &point) const;
 
-    QRay3D &transform(const QMatrix4x4 &matrix);
-    QRay3D transformed(const QMatrix4x4 &matrix) const;
+    QRay3D &transform(const Matrix4x4 &matrix);
+    QRay3D transformed(const Matrix4x4 &matrix) const;
 
     bool operator==(const QRay3D &other) const;
     bool operator!=(const QRay3D &other) const;
 
 private:
-    QVector3D m_origin;
-    QVector3D m_direction;
+    Vector3D m_origin;
+    Vector3D m_direction;
     float m_distance;
 };
 QT3D_DECLARE_TYPEINFO_2(Qt3DRender, RayCasting, QRay3D, Q_MOVABLE_TYPE)
diff --git a/src/render/raycasting/qraycastingservice.cpp b/src/render/raycasting/qraycastingservice.cpp
index e0c7b6199..8debeac6a 100644
--- a/src/render/raycasting/qraycastingservice.cpp
+++ b/src/render/raycasting/qraycastingservice.cpp
@@ -67,8 +67,8 @@ struct Hit
     bool intersects;
     float distance;
     Qt3DCore::QNodeId id;
-    QVector3D intersection;
-    QVector3D uvw;
+    Vector3D intersection;
+    Vector3D uvw;
 };
 
 bool compareHitsDistance(const Hit &a, const Hit &b)
diff --git a/src/render/render.pro b/src/render/render.pro
index c31db94b7..e8f192643 100644
--- a/src/render/render.pro
+++ b/src/render/render.pro
@@ -28,10 +28,21 @@ gcov {
     QMAKE_LFLAGS += -fprofile-arcs -ftest-coverage
 }
 
+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
+}
+
 HEADERS += \
     renderlogging_p.h \
     qt3drender_global.h \
-    qt3drender_global_p.h
+    qt3drender_global_p.h \
+    aligned_malloc_p.h
 
 # otherwise mingw headers do not declare common functions like ::strcasecmp
 win32-g++*:QMAKE_CXXFLAGS_CXX11 = -std=gnu++0x
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/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/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/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 50e33e272..1f6cb58a0 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::PickBoundingVolumeJob::intersectionRay(viewport.center().toPoint(),
-                                                                            camera.viewMatrix(),
-                                                                            camera.projectionMatrix(),
+                                                                            Matrix4x4(camera.viewMatrix()),
+                                                                            Matrix4x4(camera.projectionMatrix()),
                                                                             viewport.toRect());
-    Qt3DRender::Render::Sphere s(QVector3D(0.0f, 0.5f, 0.0f), 1.0f);
+    Qt3DRender::Render::Sphere s(Vector3D(0.0f, 0.5f, 0.0f), 1.0f);
 
     // WHEN
     bool intersects = s.intersects(ray, nullptr);
@@ -338,8 +338,8 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::PickBoundingVolumeJob::intersectionRay(viewport.topLeft().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
+                                                                     Matrix4x4(camera.viewMatrix()),
+                                                                     Matrix4x4(camera.projectionMatrix()),
                                                                      viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
@@ -348,8 +348,8 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::PickBoundingVolumeJob::intersectionRay(viewport.topRight().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
+                                                                     Matrix4x4(camera.viewMatrix()),
+                                                                     Matrix4x4(camera.projectionMatrix()),
                                                                      viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
@@ -358,8 +358,8 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::PickBoundingVolumeJob::intersectionRay(viewport.bottomLeft().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
+                                                                     Matrix4x4(camera.viewMatrix()),
+                                                                     Matrix4x4(camera.projectionMatrix()),
                                                                      viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
@@ -368,8 +368,8 @@ void tst_RayCasting::mousePicking()
 
     // WHEN
     ray = Qt3DRender::Render::PickBoundingVolumeJob::intersectionRay(viewport.bottomRight().toPoint(),
-                                                                     camera.viewMatrix(),
-                                                                     camera.projectionMatrix(),
+                                                                     Matrix4x4(camera.viewMatrix()),
+                                                                     Matrix4x4(camera.projectionMatrix()),
                                                                      viewport.toRect());
     intersects = s.intersects(ray, nullptr);
 
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 9355d8310..7e36f97ab 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 \
@@ -114,6 +110,16 @@ qtConfig(private_tests) {
         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/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 1309249d7..c361a8d92 100644
--- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -555,14 +555,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 2c8486ed0..4ad869219 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 fa0dce6af..eaa5a4e06 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/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..6a9be5e13 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;
@@ -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));
     }
 };