Expose picking details to front end

Intersection (world and local) and distance added to pick event
Modified test so that it includes the event

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

2 files changed, 50 insertions, 41 deletions

diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index b0d0ab865..c592b348f 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -35,6 +35,7 @@
 ****************************************************************************/
 
 #include "pickboundingvolumejob_p.h"
+#include "qpickevent.h"
 #include <Qt3DRender/private/renderer_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/framegraphnode_p.h>
@@ -260,19 +261,19 @@ void PickBoundingVolumeJob::run()
                 m_hoveredPickersToClear = m_hoveredPickers;
                 ObjectPicker *lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);
                 Q_FOREACH (const ViewportCameraPair &vc, vcPairs) {
-                    QVector<Qt3DCore::QNodeId> sphereHits = sphereHitsForViewportAndCamera(event.pos(),
-                                                                                           vc.viewport,
-                                                                                           vc.cameraId,
-                                                                                           rayCasting,
-                                                                                           &sphereGatherer);
+                    QVector<QCollisionQueryResult::Hit> sphereHits = sphereHitsForViewportAndCamera(event.pos(),
+                                                                                                    vc.viewport,
+                                                                                                    vc.cameraId,
+                                                                                                    rayCasting,
+                                                                                                    &sphereGatherer);
 #if 0
-                    Q_FOREACH (const Qt3DCore::QNodeId sphereEntityId, sphereHits) {
+                    Q_FOREACH (const Qt3DCore::QCollisionQueryResult::Hit sphereHit, sphereHits) {
                         if (triangleHitsForViewportAndCamera(event.pos(),
                                                              vc.viewport,
                                                              vc.cameraId,
-                                                             sphereEntityId,
+                                                             sphereHit.m_entityId,
                                                              rayCasting).isEmpty())
-                            sphereHits.removeAll(sphereEntityId);
+                            sphereHits.removeAll(sphereHit);
                     }
 #endif
 
@@ -286,8 +287,8 @@ void PickBoundingVolumeJob::run()
                         // We want to gather hits against triangles
                         // build a triangle based bounding volume
 
-                        Q_FOREACH (const Qt3DCore::QNodeId &entityId, sphereHits) {
-                            Entity *entity = m_manager->renderNodesManager()->lookupResource(entityId);
+                        Q_FOREACH (const QCollisionQueryResult::Hit &hit, sphereHits) {
+                            Entity *entity = m_manager->renderNodesManager()->lookupResource(hit.m_entityId);
                             HObjectPicker objectPickerHandle = entity->componentHandle<ObjectPicker, 16>();
 
                             // If the Entity which actually received the hit doesn't have
@@ -302,26 +303,31 @@ void PickBoundingVolumeJob::run()
 
                             if (objectPicker != Q_NULLPTR) {
                                 // Send the corresponding event
+                                QVector3D localIntersection = hit.m_intersection;
+                                if (entity && entity->worldTransform())
+                                    localIntersection = hit.m_intersection * entity->worldTransform()->inverted();
+                                QPickEventPtr pickEvent(new QPickEvent(hit.m_intersection, localIntersection, hit.m_distance));
+
                                 switch (event.type()) {
                                 case QEvent::MouseButtonPress: {
                                     // Store pressed object handle
                                     m_currentPicker = objectPickerHandle;
                                     // Send pressed event to m_currentPicker
-                                    objectPicker->onPressed();
+                                    objectPicker->onPressed(pickEvent);
                                 }
                                     break;
 
                                 case QEvent::MouseButtonRelease: {
                                     // Send release event to m_currentPicker
                                     if (lastCurrentPicker != Q_NULLPTR) {
-                                        lastCurrentPicker->onClicked();
-                                        lastCurrentPicker->onReleased();
+                                        lastCurrentPicker->onClicked(pickEvent);
+                                        lastCurrentPicker->onReleased(pickEvent);
                                     }
                                     break;
                                 }
 
                                 case Qt::TapGesture: {
-                                    objectPicker->onClicked();
+                                    objectPicker->onClicked(pickEvent);
                                     break;
                                 }
 
@@ -354,8 +360,10 @@ void PickBoundingVolumeJob::run()
                         switch (event.type()) {
                         case QEvent::MouseButtonRelease: {
                             // Send release event to m_currentPicker
-                            if (lastCurrentPicker != Q_NULLPTR)
-                                lastCurrentPicker->onReleased();
+                            if (lastCurrentPicker != Q_NULLPTR) {
+                                QPickEventPtr pickEvent(new QPickEvent);
+                                lastCurrentPicker->onReleased(pickEvent);
+                            }
                             break;
                         }
                         default:
@@ -409,11 +417,11 @@ QRect PickBoundingVolumeJob::windowViewport(const QRectF &relativeViewport) cons
 }
 
 
-QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::sphereHitsForViewportAndCamera(const QPoint &pos,
-                                                                                 const QRectF &relativeViewport,
-                                                                                 const Qt3DCore::QNodeId &cameraId,
-                                                                                 QAbstractCollisionQueryService *rayCasting,
-                                                                                 QBoundingVolumeProvider *volumeProvider) const
+QVector<QCollisionQueryResult::Hit> PickBoundingVolumeJob::sphereHitsForViewportAndCamera(const QPoint &pos,
+                                                                                          const QRectF &relativeViewport,
+                                                                                          const Qt3DCore::QNodeId &cameraId,
+                                                                                          QAbstractCollisionQueryService *rayCasting,
+                                                                                          QBoundingVolumeProvider *volumeProvider) const
 {
     QMatrix4x4 viewMatrix;
     QMatrix4x4 projectionMatrix;
@@ -428,14 +436,14 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::sphereHitsForViewportAndCamera
     const Qt3DCore::QRay3D ray = intersectionRay(glCorrectPos, viewMatrix, projectionMatrix, viewport);
     const QQueryHandle rayCastingHandle = rayCasting->query(ray, QAbstractCollisionQueryService::AllHits, volumeProvider);
     const QCollisionQueryResult queryResult = rayCasting->fetchResult(rayCastingHandle);
-    return queryResult.entitiesHit();
+    return queryResult.hits();
 }
 
-QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::triangleHitsForViewportAndCamera(const QPoint &pos,
-                                                                                   const QRectF &relativeViewport,
-                                                                                   const Qt3DCore::QNodeId &cameraId,
-                                                                                   const Qt3DCore::QNodeId &entityId,
-                                                                                   QAbstractCollisionQueryService *rayCasting) const
+QVector<QCollisionQueryResult::Hit> PickBoundingVolumeJob::triangleHitsForViewportAndCamera(const QPoint &pos,
+                                                                                            const QRectF &relativeViewport,
+                                                                                            const Qt3DCore::QNodeId &cameraId,
+                                                                                            const Qt3DCore::QNodeId &entityId,
+                                                                                            QAbstractCollisionQueryService *rayCasting) const
 {
     QMatrix4x4 viewMatrix;
     QMatrix4x4 projectionMatrix;
@@ -457,7 +465,7 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::triangleHitsForViewportAndCame
                                                             QAbstractCollisionQueryService::AllHits,
                                                             &boundingVolumeProvider);
     const QCollisionQueryResult queryResult = rayCasting->fetchResult(rayCastingHandle);
-    return queryResult.entitiesHit();
+    return queryResult.hits();
 }
 
 void PickBoundingVolumeJob::clearPreviouslyHoveredPickers()
diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h
index 11a7a1596..37f5bcc41 100644
--- a/src/render/jobs/pickboundingvolumejob_p.h
+++ b/src/render/jobs/pickboundingvolumejob_p.h
@@ -49,11 +49,12 @@
 //
 
 #include <Qt3DCore/qaspectjob.h>
-#include <Qt3DRender/private/qboundingvolumeprovider_p.h>
-#include <Qt3DRender/private/handle_types_p.h>
 #include <Qt3DCore/qray3d.h>
-#include <QSharedPointer>
+#include <Qt3DRender/private/handle_types_p.h>
+#include <Qt3DRender/private/qboundingvolumeprovider_p.h>
+#include <Qt3DRender/private/qcollisionqueryresult_p.h>
 #include <QMouseEvent>
+#include <QSharedPointer>
 
 QT_BEGIN_NAMESPACE
 
@@ -95,16 +96,16 @@ private:
                              QMatrix4x4 &viewMatrix,
                              QMatrix4x4 &projectionMatrix) const;
     QRect windowViewport(const QRectF &relativeViewport) const;
-    QVector<Qt3DCore::QNodeId> sphereHitsForViewportAndCamera(const QPoint &pos,
-                                                              const QRectF &relativeViewport,
-                                                              const Qt3DCore::QNodeId &cameraId,
-                                                              Qt3DRender::QAbstractCollisionQueryService *rayCasting,
-                                                              Qt3DRender::QBoundingVolumeProvider *volumeProvider) const;
-    QVector<Qt3DCore::QNodeId> triangleHitsForViewportAndCamera(const QPoint &pos,
-                                                                const QRectF &relativeViewport,
-                                                                const Qt3DCore::QNodeId &cameraId,
-                                                                const Qt3DCore::QNodeId &entityId,
-                                                                Qt3DRender::QAbstractCollisionQueryService *rayCasting) const;
+    QVector<QCollisionQueryResult::Hit> sphereHitsForViewportAndCamera(const QPoint &pos,
+                                                                       const QRectF &relativeViewport,
+                                                                       const Qt3DCore::QNodeId &cameraId,
+                                                                       QAbstractCollisionQueryService *rayCasting,
+                                                                       QBoundingVolumeProvider *volumeProvider) const;
+    QVector<QCollisionQueryResult::Hit> triangleHitsForViewportAndCamera(const QPoint &pos,
+                                                                         const QRectF &relativeViewport,
+                                                                         const Qt3DCore::QNodeId &cameraId,
+                                                                         const Qt3DCore::QNodeId &entityId,
+                                                                         QAbstractCollisionQueryService *rayCasting) const;
     void clearPreviouslyHoveredPickers();
     HObjectPicker m_currentPicker;
     QVector<HObjectPicker> m_hoveredPickers;