QObjectPicker and QPickingSettings NearestPriorityPick picking mode

Add a new priority property on QObjectPicker and a new QPickingSettings mode.
This will select the result with the highest priority if there are several results
on a given ray. If we have several results with identical properties, the result
with the closest distance is selected.

[ChangeLog][Qt3DRender] QObjectPicker: add a priority based result selection

Change-Id: I7af12db6e163c3c2d9dad696e6d9f9bbbee064ed
Reviewed-by: Mike Krus <mike.krus@kdab.com>

5 files changed, 436 insertions, 1 deletions

diff --git a/tests/auto/render/objectpicker/tst_objectpicker.cpp b/tests/auto/render/objectpicker/tst_objectpicker.cpp
index c1b06ccd8..644849102 100644
--- a/tests/auto/render/objectpicker/tst_objectpicker.cpp
+++ b/tests/auto/render/objectpicker/tst_objectpicker.cpp
@@ -47,6 +47,7 @@ private Q_SLOTS:
         Qt3DRender::Render::ObjectPicker objectPicker;
         Qt3DRender::QObjectPicker picker;
         picker.setHoverEnabled(true);
+        picker.setPriority(883);
 
         // WHEN
         simulateInitialization(&picker, &objectPicker);
@@ -54,6 +55,7 @@ private Q_SLOTS:
         // THEN
         QVERIFY(!objectPicker.peerId().isNull());
         QCOMPARE(objectPicker.isHoverEnabled(), true);
+        QCOMPARE(objectPicker.priority(), 883);
     }
 
     void checkInitialAndCleanedUpState()
@@ -64,10 +66,14 @@ private Q_SLOTS:
         // THEN
         QVERIFY(objectPicker.peerId().isNull());
         QCOMPARE(objectPicker.isHoverEnabled(), false);
+        QCOMPARE(objectPicker.isDragEnabled(), false);
+        QCOMPARE(objectPicker.priority(), 0);
 
         // GIVEN
         Qt3DRender::QObjectPicker picker;
         picker.setHoverEnabled(true);
+        picker.setDragEnabled(true);
+        picker.setPriority(1584);
 
         // WHEN
         simulateInitialization(&picker, &objectPicker);
@@ -75,6 +81,8 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(objectPicker.isHoverEnabled(), false);
+        QCOMPARE(objectPicker.isDragEnabled(), false);
+        QCOMPARE(objectPicker.priority(), 0);
     }
 
     void checkPropertyChanges()
@@ -95,6 +103,34 @@ private Q_SLOTS:
             QCOMPARE(objectPicker.isHoverEnabled(), true);
             QVERIFY(renderer.dirtyBits() != 0);
         }
+        {
+            Qt3DRender::Render::ObjectPicker objectPicker;
+            objectPicker.setRenderer(&renderer);
+
+            // WHEN
+            Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
+            updateChange->setValue(true);
+            updateChange->setPropertyName("dragEnabled");
+            objectPicker.sceneChangeEvent(updateChange);
+
+            // THEN
+            QCOMPARE(objectPicker.isDragEnabled(), true);
+            QVERIFY(renderer.dirtyBits() != 0);
+        }
+        {
+            Qt3DRender::Render::ObjectPicker objectPicker;
+            objectPicker.setRenderer(&renderer);
+
+            // WHEN
+            Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
+            updateChange->setValue(15);
+            updateChange->setPropertyName("priority");
+            objectPicker.sceneChangeEvent(updateChange);
+
+            // THEN
+            QCOMPARE(objectPicker.priority(), 15);
+            QVERIFY(renderer.dirtyBits() != 0);
+        }
     }
 
     void checkBackendPropertyNotifications()
diff --git a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
index feef480e2..e1506de86 100644
--- a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
+++ b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc
@@ -10,5 +10,6 @@
         <file>testscene_parententity.qml</file>
         <file>testscene_viewports.qml</file>
         <file>testscene_cameraposition.qml</file>
+        <file>testscene_priorityoverlapping.qml</file>
     </qresource>
 </RCC>
diff --git a/tests/auto/render/pickboundingvolumejob/testscene_priorityoverlapping.qml b/tests/auto/render/pickboundingvolumejob/testscene_priorityoverlapping.qml
new file mode 100644
index 000000000..7cacb3d2d
--- /dev/null
+++ b/tests/auto/render/pickboundingvolumejob/testscene_priorityoverlapping.qml
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** BSD License Usage
+** Alternatively, you may use this file under the terms of the BSD license
+** as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import Qt3D.Core 2.0
+import Qt3D.Render 2.13
+import Qt3D.Extras 2.0
+import QtQuick.Window 2.0
+
+Entity {
+    id: sceneRoot
+
+    Window {
+        id: win
+        width: 600
+        height: 600
+        visible: true
+    }
+
+    Camera {
+        id: camera
+        projectionType: CameraLens.PerspectiveProjection
+        fieldOfView: 45
+        nearPlane : 0.1
+        farPlane : 1000.0
+        position: Qt.vector3d( 0.0, 0.0, -40.0 )
+        upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+        viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
+    }
+
+    components: [
+        RenderSettings {
+            activeFrameGraph: Viewport {
+                normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
+
+                RenderSurfaceSelector {
+                    surface: win
+
+                    ClearBuffers {
+                        buffers : ClearBuffers.ColorDepthBuffer
+                        NoDraw {}
+                    }
+
+                    CameraSelector {
+                        camera: camera
+                    }
+                }
+            }
+            pickingSettings {
+                pickResultMode: PickingSettings.NearestPriorityPick
+                pickMethod: PickingSettings.TrianglePicking
+                faceOrientationPickingMode: PickingSettings.FrontAndBackFace
+            }
+        }
+    ]
+
+    CuboidMesh { id: cubeMesh }
+    PhongMaterial { id: material }
+
+    // Entity 1
+    Entity {
+        property ObjectPicker picker: ObjectPicker {
+            id: picker1
+            objectName: "Picker1"
+        }
+
+        property Transform transform: Transform {
+            translation: Qt.vector3d(0, 0, 0)
+            scale: 2.0
+        }
+
+        components: [cubeMesh, material, picker1, transform]
+    }
+
+    // Entity 2
+    Entity {
+        property ObjectPicker picker: ObjectPicker {
+            id: picker2
+            objectName: "Picker2"
+        }
+
+        property Transform transform: Transform {
+            translation: Qt.vector3d(0, 0, 10)
+            scale: 2.5
+        }
+
+        components: [cubeMesh, material, picker2, transform]
+    }
+}
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index 60b60eb6e..5e51c8aa7 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -1473,6 +1473,111 @@ private Q_SLOTS:
         arbiter.events.clear();
     }
 
+    void checkPriorityPicking()
+    {
+        // GIVEN
+        QmlSceneReader sceneReader(QUrl("qrc:/testscene_priorityoverlapping.qml"));
+        QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root()));
+        QVERIFY(root);
+
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
+        TestArbiter arbiter1;
+        TestArbiter arbiter2;
+
+        // Runs Required jobs
+        runRequiredJobs(test.data());
+
+        // THEN
+        QList<Qt3DRender::QObjectPicker *> pickers = root->findChildren<Qt3DRender::QObjectPicker *>();
+        QCOMPARE(pickers.size(), 2);
+
+        Qt3DRender::QObjectPicker *picker1 = nullptr;
+        Qt3DRender::QObjectPicker *picker2 = nullptr;
+        if (pickers.first()->objectName() == QLatin1String("Picker1")) {
+            picker1 = pickers.first();
+            picker2 = pickers.last();
+        } else {
+            picker1 = pickers.last();
+            picker2 = pickers.first();
+        }
+
+        Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
+        QVERIFY(backendPicker1);
+        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter1);
+
+        Qt3DRender::Render::ObjectPicker *backendPicker2 = test->nodeManagers()->objectPickerManager()->lookupResource(picker2->id());
+        QVERIFY(backendPicker2);
+        Qt3DCore::QBackendNodePrivate::get(backendPicker2)->setArbiter(&arbiter2);
+
+
+        // WHEN both have priority == 0, select closest
+        {
+            Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
+            initializePickBoundingVolumeJob(&pickBVJob, test.data());
+
+            // WHEN -> Pressed on object
+            QList<QPair<QObject *, QMouseEvent>> events;
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300.0f, 300.0f),
+                                                   Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+            pickBVJob.setMouseEvents(events);
+            bool earlyReturn = !pickBVJob.runHelper();
+
+            // THEN -> Select picker with highest priority
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker1->isPressed());
+            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter1.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+            QCOMPARE(change->propertyName(), "pressed");
+
+            QVERIFY(!backendPicker2->isPressed());
+            QVERIFY(arbiter2.events.isEmpty());
+
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300.0f, 300.0f),
+                                                   Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+            pickBVJob.setMouseEvents(events);
+            pickBVJob.runHelper();
+            arbiter1.events.clear();
+            arbiter2.events.clear();
+
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!backendPicker2->isPressed());
+        }
+
+        // WHEN furthest one has higher priority, select furthest one
+        {
+            backendPicker2->setPriority(1000);
+            QCOMPARE(backendPicker2->priority(), 1000);
+
+            Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
+            initializePickBoundingVolumeJob(&pickBVJob, test.data());
+
+            // WHEN -> Pressed on object
+            QList<QPair<QObject *, QMouseEvent>> events;
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300.0f, 300.0f),
+                                                   Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+            pickBVJob.setMouseEvents(events);
+            bool earlyReturn = !pickBVJob.runHelper();
+
+            // THEN -> Select picker with highest priority
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker2->isPressed());
+            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter2.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+            QCOMPARE(change->propertyName(), "pressed");
+
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(arbiter1.events.isEmpty());
+
+            events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300.0f, 300.0f),
+                                                   Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)});
+            pickBVJob.setMouseEvents(events);
+            pickBVJob.runHelper();
+            arbiter1.events.clear();
+            arbiter2.events.clear();
+
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!backendPicker2->isPressed());
+        }
+    }
+
 };
 
 QTEST_MAIN(tst_PickBoundingVolumeJob)
diff --git a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
index 6714d8a06..bd486774c 100644
--- a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
+++ b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
@@ -31,8 +31,10 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DRender/QObjectPicker>
+#include <Qt3DRender/private/qobjectpicker_p.h>
 #include <Qt3DRender/QPickEvent>
-
+#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
+#include <Qt3DCore/qnodecreatedchange.h>
 #include "testpostmanarbiter.h"
 
 class MyObjectPicker : public Qt3DRender::QObjectPicker
@@ -71,6 +73,162 @@ public:
 
 private Q_SLOTS:
 
+    void checkInitialState()
+    {
+        // GIVEN
+        Qt3DRender::QObjectPicker picker;
+
+        // THEN
+        QCOMPARE(picker.priority(), 0);
+        QCOMPARE(picker.isDragEnabled(), false);
+        QCOMPARE(picker.isHoverEnabled(), false);
+    }
+
+    void checkCreationData()
+    {
+        // GIVEN
+        Qt3DRender::QObjectPicker picker;
+
+        picker.setPriority(1584);
+        picker.setDragEnabled(true);
+        picker.setHoverEnabled(true);
+
+        // WHEN
+        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
+
+        {
+            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&picker);
+            creationChanges = creationChangeGenerator.creationChanges();
+        }
+
+        // THEN
+        {
+            QCOMPARE(creationChanges.size(), 1);
+
+            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QObjectPickerData>>(creationChanges.first());
+            const Qt3DRender::QObjectPickerData cloneData = creationChangeData->data;
+
+            QCOMPARE(cloneData.priority, 1584);
+            QCOMPARE(cloneData.hoverEnabled, true);
+            QCOMPARE(cloneData.dragEnabled, true);
+            QCOMPARE(picker.id(), creationChangeData->subjectId());
+            QCOMPARE(picker.isEnabled(), true);
+            QCOMPARE(picker.isEnabled(), creationChangeData->isNodeEnabled());
+            QCOMPARE(picker.metaObject(), creationChangeData->metaObject());
+        }
+
+        // WHEN
+        picker.setEnabled(false);
+
+        {
+            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&picker);
+            creationChanges = creationChangeGenerator.creationChanges();
+        }
+
+        // THEN
+        {
+            QCOMPARE(creationChanges.size(), 1);
+
+            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QObjectPickerData>>(creationChanges.first());
+            const Qt3DRender::QObjectPickerData cloneData = creationChangeData->data;
+
+            QCOMPARE(cloneData.priority, 1584);
+            QCOMPARE(cloneData.hoverEnabled, true);
+            QCOMPARE(cloneData.dragEnabled, true);
+            QCOMPARE(picker.id(), creationChangeData->subjectId());
+            QCOMPARE(picker.isEnabled(), false);
+            QCOMPARE(picker.isEnabled(), creationChangeData->isNodeEnabled());
+            QCOMPARE(picker.metaObject(), creationChangeData->metaObject());
+        }
+    }
+
+    void checkPropertyUpdate()
+    {
+        // GIVEN
+        TestArbiter arbiter;
+        Qt3DRender::QObjectPicker picker;
+        arbiter.setArbiterOnNode(&picker);
+
+        {
+            {
+                // WHEN
+                picker.setPriority(883);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 1);
+                QCOMPARE(picker.priority(), 883);
+                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+                QCOMPARE(change->propertyName(), "priority");
+                QCOMPARE(change->value().value<int>(), picker.priority());
+                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+
+                arbiter.events.clear();
+            }
+
+            {
+                // WHEN
+                picker.setPriority(883);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 0);
+            }
+        }
+        {
+            {
+                // WHEN
+                picker.setDragEnabled(true);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 1);
+                QCOMPARE(picker.isDragEnabled(), true);
+                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+                QCOMPARE(change->propertyName(), "dragEnabled");
+                QCOMPARE(change->value().value<bool>(), picker.isDragEnabled());
+                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+
+                arbiter.events.clear();
+            }
+
+            {
+                // WHEN
+                picker.setDragEnabled(true);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 0);
+            }
+        }
+        {
+            {
+                // WHEN
+                picker.setHoverEnabled(true);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 1);
+                QCOMPARE(picker.isHoverEnabled(), true);
+                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+                QCOMPARE(change->propertyName(), "hoverEnabled");
+                QCOMPARE(change->value().value<bool>(), picker.isHoverEnabled());
+                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+
+                arbiter.events.clear();
+            }
+
+            {
+                // WHEN
+                picker.setHoverEnabled(true);
+                QCoreApplication::processEvents();
+
+                // THEN
+                QCOMPARE(arbiter.events.size(), 0);
+            }
+        }
+    }
+
     void checkCloning_data()
     {
         QTest::addColumn<Qt3DRender::QObjectPicker *>("objectPicker");