Merge branch '5.9' into 5.10

Conflicts:
	src/render/backend/cameralens.cpp
	src/render/backend/cameralens_p.h
	src/render/jobs/pickboundingvolumejob.cpp
	src/render/jobs/updatelevelofdetailjob.cpp

Change-Id: I5433dde8ace462d11f037742d45f555c87235ffe

9 files changed, 139 insertions, 71 deletions

diff --git a/examples/qt3d/anaglyph-rendering/StereoCamera.qml b/examples/qt3d/anaglyph-rendering/StereoCamera.qml
index c8db4c0a9..ea013c0b0 100644
--- a/examples/qt3d/anaglyph-rendering/StereoCamera.qml
+++ b/examples/qt3d/anaglyph-rendering/StereoCamera.qml
@@ -62,6 +62,7 @@ Entity {
 
     property vector3d viewCenter: Qt.vector3d(0.0, 0.0, 0.0)
     property vector3d position: Qt.vector3d(0.0, 0.0, 1.0)
+    property vector3d upVector: Qt.vector3d(0.0, 1.0, 0.0)
 
     readonly property real _fov2: Math.tan(fieldOfView * Math.PI / 180 * 0.5)
     readonly property real top: nearPlane * _fov2
@@ -94,23 +95,26 @@ Entity {
 
         matrix: {
             var m = Qt.matrix4x4();
-            m.lookAt(root.position, root.viewCenter, Qt.vector3d(0.0, 1.0, 0.0));
-            return m;
+            m.translate(root.position)
+            var zAxis = root.position.minus(root.viewCenter).normalized()
+            var xAxis = root.upVector.crossProduct(zAxis).normalized();
+            var yAxis = zAxis.crossProduct(xAxis);
+            var r = Qt.matrix4x4(xAxis.x, yAxis.x, zAxis.x, 0,
+                                 xAxis.y, yAxis.y, zAxis.y, 0,
+                                 xAxis.z, yAxis.z, zAxis.z, 0,
+                                 0, 0, 0, 1)
+            return m.times(r);
         }
     }
 
+    components: [ eyeTransform ]
+
     property Entity leftCamera: Entity {
-        components: [
-            leftEyeLens,
-            eyeTransform
-        ]
+        components: [ leftEyeLens ]
     }
 
     property Entity rightCamera: Entity {
         id: rightCameraEntity
-        components: [
-            rightEyeLens,
-            eyeTransform
-        ]
+        components: [ rightEyeLens ]
     }
 }
diff --git a/examples/qt3d/multiviewport/SimpleCamera.qml b/examples/qt3d/multiviewport/SimpleCamera.qml
index e1cb95426..20741ae20 100644
--- a/examples/qt3d/multiviewport/SimpleCamera.qml
+++ b/examples/qt3d/multiviewport/SimpleCamera.qml
@@ -65,8 +65,15 @@ Entity {
         id: transform
         matrix: {
             var m = Qt.matrix4x4();
-            m.lookAt(root.position, root.viewCenter, root.upVector);
-            return m;
+            m.translate(root.position)
+            var zAxis = root.position.minus(root.viewCenter).normalized()
+            var xAxis = root.upVector.crossProduct(zAxis).normalized();
+            var yAxis = zAxis.crossProduct(xAxis);
+            var r = Qt.matrix4x4(xAxis.x, yAxis.x, zAxis.x, 0,
+                                 xAxis.y, yAxis.y, zAxis.y, 0,
+                                 xAxis.z, yAxis.z, zAxis.z, 0,
+                                 0, 0, 0, 1)
+            return m.times(r);
         }
     }
 }
diff --git a/examples/qt3d/qardboard/QardboardCamera.qml b/examples/qt3d/qardboard/QardboardCamera.qml
index 1912b8a22..4832aeadc 100644
--- a/examples/qt3d/qardboard/QardboardCamera.qml
+++ b/examples/qt3d/qardboard/QardboardCamera.qml
@@ -50,6 +50,7 @@
 
 import Qt3D.Core 2.0
 import Qt3D.Render 2.0
+import Qardboard 1.0
 
 Entity {
     id: root
@@ -63,12 +64,17 @@ Entity {
     property vector3d position: Qt.vector3d(0.0, 0.0, 0.0)
     property vector3d viewDirection: Qt.vector3d(0.0, 0.0, 1.0)
     property vector3d viewUp: Qt.vector3d(0.0, 1.0, 0.0)
-    property alias viewMatrix: leftEyeTransform.matrix
+    property alias viewMatrix: eyeTransform.matrix
 
     readonly property real _fov2: Math.tan(fieldOfView * Math.PI / 180 * 0.5)
     readonly property real top: nearPlane * _fov2
     readonly property real a: aspectRatio * _fov2 * convergence
 
+    DeviceOrientation {
+        id: orientation
+        enabled: true
+    }
+
     CameraLens {
         id: leftEyeLens
         projectionType: CameraLens.FrustumProjection
@@ -92,33 +98,39 @@ Entity {
     }
 
     Transform {
-        id: leftEyeTransform
+        id: eyeTransform
+
+        function computeMatrix(roll, pitch, yaw) {
+            var n = Qt.matrix4x4()
+            n.rotate(-roll, Qt.vector3d(1, 0, 0))
+            n.rotate(yaw, Qt.vector3d(0, 1, 0))
+            var vd = n.times(stereoCamera.viewDirection)
+            var vu = n.times(stereoCamera.viewUp)
+            var vc = stereoCamera.position.minus(vd)
 
-        matrix: {
             var m = Qt.matrix4x4();
-            m.lookAt(root.position, root.position + root.viewDirection, root.viewUp);
-            return m;
+            m.translate(stereoCamera.position)
+            var zAxis = stereoCamera.position.minus(vc).normalized()
+            var xAxis = vu.crossProduct(zAxis).normalized();
+            var yAxis = zAxis.crossProduct(xAxis);
+            var r = Qt.matrix4x4(xAxis.x, yAxis.x, zAxis.x, 0,
+                                 xAxis.y, yAxis.y, zAxis.y, 0,
+                                 xAxis.z, yAxis.z, zAxis.z, 0,
+                                 0, 0, 0, 1)
+            return m.times(r);
         }
-    }
 
-    Transform {
-        id: rightEyeTransform
-
-        matrix: leftEyeTransform.matrix
+        matrix: computeMatrix(orientation.roll, orientation.pitch, orientation.yaw)
     }
 
+    components: [ eyeTransform ]
+
     property Entity leftCamera: Entity {
-        components: [
-            leftEyeLens,
-            leftEyeTransform
-        ]
+        components: [ leftEyeLens ]
     }
 
     property Entity rightCamera: Entity {
         id: rightCameraEntity
-        components: [
-            rightEyeLens,
-            rightEyeTransform
-        ]
+        components: [ rightEyeLens ]
     }
 }
diff --git a/examples/qt3d/qardboard/QardboardRootEntity.qml b/examples/qt3d/qardboard/QardboardRootEntity.qml
index 85e4fbc7e..004ebadc5 100644
--- a/examples/qt3d/qardboard/QardboardRootEntity.qml
+++ b/examples/qt3d/qardboard/QardboardRootEntity.qml
@@ -51,7 +51,6 @@
 import Qt3D.Core 2.0
 import Qt3D.Render 2.0
 import Qt3D.Input 2.0
-import Qardboard 1.0
 
 Entity {
     id: root
@@ -75,31 +74,7 @@ Entity {
         }
     ]
 
-    DeviceOrientation {
-        id: orientation
-        enabled: true
-    }
-
     QardboardCamera {
         id: stereoCamera
-        viewMatrix: computeMatrix(orientation.roll, orientation.pitch, orientation.yaw)
-
-        property vector3d vc
-        property vector3d vd
-        property vector3d vu
-
-        function computeMatrix(roll, pitch, yaw) {
-            var m = Qt.matrix4x4()
-            m.rotate(-roll, Qt.vector3d(1, 0, 0))
-            m.rotate(yaw, Qt.vector3d(0, 1, 0))
-            vd = m.times(stereoCamera.viewDirection)
-            vu = m.times(stereoCamera.viewUp)
-            var r = Qt.matrix4x4()
-            vc = stereoCamera.position.minus(vd)
-            r.lookAt(stereoCamera.position, vc, vu)
-//            console.log(roll.toFixed(2), pitch.toFixed(2), yaw.toFixed(2), stereoCamera.position, vd, vc, vu)
-//            console.log(r)
-            return r
-        }
     }
 }
diff --git a/src/render/backend/cameralens.cpp b/src/render/backend/cameralens.cpp
index cf1f17d32..e127b5885 100644
--- a/src/render/backend/cameralens.cpp
+++ b/src/render/backend/cameralens.cpp
@@ -105,6 +105,18 @@ void CameraLens::setRenderAspect(QRenderAspect *renderAspect)
     m_renderAspect = renderAspect;
 }
 
+QMatrix4x4 CameraLens::viewMatrix(const QMatrix4x4 &worldTransform)
+{
+    const QVector4D position = worldTransform * QVector4D(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);
+
+    QMatrix4x4 m;
+    m.lookAt(position.toVector3D(), (position + viewDirection).toVector3D(), upVector.toVector3D());
+    return m;
+}
+
 void CameraLens::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
 {
     const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QCameraLensData>>(change);
@@ -209,7 +221,7 @@ bool CameraLens::viewMatrixForCamera(EntityManager* manager, Qt3DCore::QNodeId c
     if (!lens || !lens->isEnabled())
         return false;
 
-    viewMatrix = *camNode->worldTransform();
+    viewMatrix = lens->viewMatrix(*camNode->worldTransform());
     projectionMatrix = lens->projection();
     return true;
 }
diff --git a/src/render/backend/cameralens_p.h b/src/render/backend/cameralens_p.h
index d071619d8..1afeeda24 100644
--- a/src/render/backend/cameralens_p.h
+++ b/src/render/backend/cameralens_p.h
@@ -89,6 +89,8 @@ public:
 
     void setRenderAspect(QRenderAspect* renderAspect);
 
+    QMatrix4x4 viewMatrix(const QMatrix4x4 &worldTransform);
+
     void setProjection(const QMatrix4x4 &projection);
     inline QMatrix4x4 projection() const { return m_projection; }
 
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index f488b7e44..dd5968420 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -733,16 +733,7 @@ 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 QVector4D position = cameraWorld * QVector4D(0.0f, 0.0f, 0.0f, 1.0f);
-        // OpenGL convention is looking down -Z
-        const QVector4D viewDirection = cameraWorld * QVector4D(0.0f, 0.0f, -1.0f, 0.0f);
-        const QVector4D upVector = cameraWorld * QVector4D(0.0f, 1.0f, 0.0f, 0.0f);
-
-        QMatrix4x4 m;
-        m.lookAt(position.toVector3D(), (position + viewDirection).toVector3D(), upVector.toVector3D());
-
-        setViewMatrix(m);
+        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
diff --git a/src/render/jobs/loadgeometryjob_p.h b/src/render/jobs/loadgeometryjob_p.h
index 2b0331d1c..c02739647 100644
--- a/src/render/jobs/loadgeometryjob_p.h
+++ b/src/render/jobs/loadgeometryjob_p.h
@@ -72,7 +72,7 @@ public:
     void setNodeManagers(NodeManagers *nodeManagers) { m_nodeManagers = nodeManagers; }
 
 protected:
-    void run() Q_DECL_OVERRIDE;
+    void run() override;
     HGeometryRenderer m_handle;
     NodeManagers *m_nodeManagers;
 };
diff --git a/src/render/renderstates/qcullface.cpp b/src/render/renderstates/qcullface.cpp
index e96346287..4be395464 100644
--- a/src/render/renderstates/qcullface.cpp
+++ b/src/render/renderstates/qcullface.cpp
@@ -50,7 +50,7 @@ namespace Qt3DRender {
 /*!
     \class Qt3DRender::QCullFace
     \brief The QCullFace class specifies whether front or back face culling
-    are enabled
+    is enabled.
     \since 5.7
     \inmodule Qt3DRender
     \ingroup renderstates
@@ -58,13 +58,43 @@ namespace Qt3DRender {
     QCullFace sets whether the front or back facets are culled.
     Facets include triangles, quadrilaterals, polygons and rectangles.
 
+    It can be added by calling the addRenderState() method on a QRenderPass:
+
+    \code
+    // using namespace Qt3DRender;
+
+    QRenderPass *renderPass = new QRenderPass();
+
+    // Create a front face culling render state
+    QCullFace *cullFront = new QCullFace();
+    cullFront->setMode(QCullFace::Front);
+
+    // Add the render state to the render pass
+    renderPass->addRenderState(cullFront);
+    \endcode
+
+    Or by calling the addRenderState() method on a QRenderStateSet:
+
+    \code
+    // using namespace Qt3DRender;
+
+    QRenderStateSet *renderStateSet = new QRenderStateSet();
+
+    // Create a front face culling render state
+    QCullFace *cullFront = new QCullFace();
+    cullFront->setMode(QCullFace::Front);
+
+    // Add the render state to the render pass
+    renderStateSet->addRenderState(cullFront);
+    \endcode
+
     \sa QFrontFace
  */
 
 /*!
     \qmltype CullFace
     \brief The CullFace type specifies whether front or back face culling
-    are enabled
+    is enabled.
     \since 5.7
     \inqmlmodule Qt3D.Render
     \instantiates Qt3DRender::QCullFace
@@ -74,6 +104,33 @@ namespace Qt3DRender {
     CullFace sets whether the front or back facets are culled.
     Facets include triangles, quadrilaterals, polygons and rectangles.
 
+    It can be added to the renderStates property of a RenderPass:
+
+    \qml
+    RenderPass {
+        shaderProgram: ShaderProgram {
+            // ...
+        }
+        renderStates: [
+            CullFace {
+                mode: CullFace.Front
+            }
+        ]
+    }
+    \endqml
+
+    Or added to the renderStates property of a RenderStateSet:
+
+    \qml
+    RenderStateSet {
+        renderStates: [
+            CullFace {
+                mode: CullFace.Front
+            }
+        ]
+    }
+    \endqml
+
     \sa FrontFace
  */
 
@@ -81,15 +138,23 @@ namespace Qt3DRender {
     \enum Qt3DRender::QCullFace::CullingMode
 
     This enumeration specifies values for the culling mode.
-    \value NoCulling culling is disabled
+
+    \value NoCulling Culling is disabled
     \value Front Culling is enabled for front facing polygons
     \value Back Culling is enabled for back facing polygons
-    \value FrontAndBack Culling is enabled for all polygons, points and lines are drawn.
+    \value FrontAndBack Culling is enabled for all polygons, points and lines are drawn
 */
 
 /*!
     \qmlproperty enumeration CullFace::mode
     Holds the culling mode used by CullFace. Default is set to QCullFace.Back.
+
+    \list
+    \li CullFace.NoCulling - culling is disabled
+    \li CullFace.Front - culling is enabled for front facing polygons
+    \li CullFace.Back - culling is enabled for back facing polygons
+    \li CullFace.FrontAndBack - culling is enabled for all polygons, but points and lines are drawn
+    \endlist
 */
 
 /*!