pickboundingvolumejob.cpp

++ // Copyright (C) 2015 Paul Lemire paul.lemire350@gmail.com

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++

++ #include "pickboundingvolumejob_p.h"

++ #include "qpicktriangleevent.h"

++ #include "qpicklineevent.h"

++ #include "qpickpointevent.h"

++ #include <Qt3DCore/private/qaspectmanager_p.h>

++ #include <Qt3DCore/private/vector_helper_p.h>

++ #include <Qt3DRender/qobjectpicker.h>

++ #include <Qt3DRender/qviewport.h>

++ #include <Qt3DRender/qgeometryrenderer.h>

++ #include <Qt3DRender/private/qobjectpicker_p.h>

++ #include <Qt3DRender/private/nodemanagers_p.h>

++ #include <Qt3DRender/private/entity_p.h>

++ #include <Qt3DRender/private/objectpicker_p.h>

++ #include <Qt3DRender/private/managers_p.h>

++ #include <Qt3DRender/private/geometryrenderer_p.h>

++ #include <Qt3DRender/private/rendersettings_p.h>

++ #include <Qt3DRender/private/trianglesvisitor_p.h>

++ #include <Qt3DRender/private/job_common_p.h>

++ #include <Qt3DRender/private/qpickevent_p.h>

++ #include <Qt3DRender/private/pickboundingvolumeutils_p.h>

++

++ #include <QSurface>

++ #include <QWindow>

++ #include <QOffscreenSurface>

++

++ QT_BEGIN_NAMESPACE

++

++ namespace Qt3DRender {

++ using namespace Qt3DRender::RayCasting;

++

++ namespace Render {

++

++ class PickBoundingVolumeJobPrivate : public Qt3DCore::QAspectJobPrivate

++ {

++ public:

++     PickBoundingVolumeJobPrivate(PickBoundingVolumeJob *q) : q_ptr(q) { }

++     ~PickBoundingVolumeJobPrivate() override = default;

++

++     bool isRequired() const override;

++     void postFrame(Qt3DCore::QAspectManager *manager) override;

++

++     enum CustomEventType {

++         MouseButtonClick = QEvent::User,

++     };

++

++     struct EventDetails {

++         Qt3DCore::QNodeId pickerId;

++         int sourceEventType;

++         QPickEventPtr resultingEvent;

++         Qt3DCore::QNodeId viewportNodeId;

++     };

++

++     QList<EventDetails> dispatches;

++     PickBoundingVolumeJob *q_ptr;

++     Q_DECLARE_PUBLIC(PickBoundingVolumeJob)

++ };

++

++

++ bool PickBoundingVolumeJobPrivate::isRequired() const

++ {

++     Q_Q(const PickBoundingVolumeJob);

++     return !q->m_pendingMouseEvents.empty() || q->m_pickersDirty || q->m_oneEnabledAtLeast;

++ }

++

++ void PickBoundingVolumeJobPrivate::postFrame(Qt3DCore::QAspectManager *manager)

++ {

++     using namespace Qt3DCore;

++     QNodeId previousId;

++     QObjectPicker *node = nullptr;

++

++     for (auto res: std::as_const(dispatches)) {

++         if (previousId != res.pickerId) {

++             node = qobject_cast<QObjectPicker *>(manager->lookupNode(res.pickerId));

++             previousId = res.pickerId;

++         }

++         if (!node)

++             continue;

++

++         QObjectPickerPrivate *dnode = static_cast<QObjectPickerPrivate *>(QObjectPickerPrivate::get(node));

++

++         // resolve front end details

++         QPickEvent *pickEvent = res.resultingEvent.data();

++         if (pickEvent) {

++             QPickEventPrivate *dpickEvent = QPickEventPrivate::get(pickEvent);

++             dpickEvent->m_viewport = static_cast<QViewport *>(manager->lookupNode(res.viewportNodeId));

++             dpickEvent->m_entityPtr = static_cast<QEntity *>(manager->lookupNode(dpickEvent->m_entity));

++         }

++

++         // dispatch event

++         switch (res.sourceEventType) {

++         case QEvent::MouseButtonPress:

++             dnode->pressedEvent(pickEvent);

++             break;

++         case QEvent::MouseButtonRelease:

++             dnode->releasedEvent(pickEvent);

++             break;

++         case MouseButtonClick:

++             dnode->clickedEvent(pickEvent);

++             break;

++         case QEvent::MouseMove:

++             dnode->movedEvent(pickEvent);

++             break;

++         case QEvent::Enter:

++             emit node->entered();

++             dnode->setContainsMouse(true);

++             break;

++         case QEvent::Leave:

++             dnode->setContainsMouse(false);

++             emit node->exited();

++             break;

++         default: Q_UNREACHABLE();

++         }

++     }

++

++     dispatches.clear();

++ }

++

++ namespace {

++

++ void setEventButtonAndModifiers(const QMouseEvent *event, QPickEvent::Buttons &eventButton, int &eventButtons, int &eventModifiers)

++ {

++     switch (event->button()) {

++     case Qt::LeftButton:

++         eventButton = QPickEvent::LeftButton;

++         break;

++     case Qt::RightButton:

++         eventButton = QPickEvent::RightButton;

++         break;

++     case Qt::MiddleButton:

++         eventButton = QPickEvent::MiddleButton;

++         break;

++     case Qt::BackButton:

++         eventButton = QPickEvent::BackButton;

++         break;

++     default:

++         break;

++     }

++

++     if (event->buttons() & Qt::LeftButton)

++         eventButtons |= QPickEvent::LeftButton;

++     if (event->buttons() & Qt::RightButton)

++         eventButtons |= QPickEvent::RightButton;

++     if (event->buttons() & Qt::MiddleButton)

++         eventButtons |= QPickEvent::MiddleButton;

++     if (event->buttons() & Qt::BackButton)

++         eventButtons |= QPickEvent::BackButton;

++     if (event->modifiers() & Qt::ShiftModifier)

++         eventModifiers |= QPickEvent::ShiftModifier;

++     if (event->modifiers() & Qt::ControlModifier)

++         eventModifiers |= QPickEvent::ControlModifier;

++     if (event->modifiers() & Qt::AltModifier)

++         eventModifiers |= QPickEvent::AltModifier;

++     if (event->modifiers() & Qt::MetaModifier)

++         eventModifiers |= QPickEvent::MetaModifier;

++     if (event->modifiers() & Qt::KeypadModifier)

++         eventModifiers |= QPickEvent::KeypadModifier;

++ }

++

++ } // anonymous

++

++ PickBoundingVolumeJob::PickBoundingVolumeJob()

++     : AbstractPickingJob(*new PickBoundingVolumeJobPrivate(this))

++     , m_pickersDirty(true)

++ {

++     SET_JOB_RUN_STAT_TYPE(this, JobTypes::PickBoundingVolume, 0)

++ }

++

++ void PickBoundingVolumeJob::setRoot(Entity *root)

++ {

++     m_node = root;

++ }

++

++ bool PickBoundingVolumeJob::processMouseEvent(QObject* object, QMouseEvent *event)

++ {

++     m_pendingMouseEvents.emplace_back(object, std::unique_ptr<QMouseEvent>(static_cast<QMouseEvent *>(event->clone())));

++     return false;

++ }

++

++ void PickBoundingVolumeJob::markPickersDirty()

++ {

++     m_pickersDirty = true;

++ }

++

++ bool PickBoundingVolumeJob::runHelper()

++ {

++     // Move to clear the events so that we don't process them several times

++     // if run is called several times

++     const auto mouseEvents = Qt3DCore::moveAndClear(m_pendingMouseEvents);

++

++     // If we have no events return early

++     if (mouseEvents.empty())

++         return false;

++

++     // Quickly look which picker settings we've got

++     if (m_pickersDirty) {

++         m_pickersDirty = false;

++         m_oneEnabledAtLeast = false;

++         m_oneHoverAtLeast = false;

++

++         const auto activeHandles = m_manager->objectPickerManager()->activeHandles();

++         for (const auto &handle : activeHandles) {

++             auto picker = m_manager->objectPickerManager()->data(handle);

++             m_oneEnabledAtLeast |= picker->isEnabled();

++             m_oneHoverAtLeast |= picker->isHoverEnabled();

++             if (m_oneEnabledAtLeast && m_oneHoverAtLeast)

++                 break;

++         }

++     }

++

++     // bail out early if no picker is enabled

++     if (!m_oneEnabledAtLeast)

++         return false;

++

++     bool hasMoveEvent = false;

++     bool hasOtherEvent = false;

++     // Quickly look which types of events we've got

++     for (const auto &event : mouseEvents) {

++         const bool isMove = (event.second->type() == QEvent::MouseMove);

++         hasMoveEvent |= isMove;

++         hasOtherEvent |= !isMove;

++     }

++

++     // In the case we have a move event, find if we actually have

++     // an object picker that cares about these

++     if (!hasOtherEvent) {

++         // Retrieve the last used object picker

++         ObjectPicker *lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);

++

++         // The only way to set lastCurrentPicker is to click

++         // so we can return since if we're there it means we

++         // have only move events. But keep on if hover support

++         // is needed

++         if (lastCurrentPicker == nullptr && !m_oneHoverAtLeast)

++             return false;

++

++         const bool caresAboutMove = (hasMoveEvent &&

++                                       (m_oneHoverAtLeast ||

++                                         (lastCurrentPicker && lastCurrentPicker->isDragEnabled())));

++         // Early return if the current object picker doesn't care about move events

++         if (!caresAboutMove)

++             return false;

++     }

++

++     const PickingUtils::PickConfiguration pickConfiguration(m_frameGraphRoot, m_renderSettings);

++     if (pickConfiguration.vcaDetails.empty())

++         return false;

++

++     // TO DO:

++     // If we have move or hover move events that someone cares about, we try to avoid expensive computations

++     // by compressing them into a single one

++

++     // For each mouse event

++     for (const auto &event : mouseEvents)

++         processPickEvent(pickConfiguration, event.first, event.second.get());

++

++     // Clear Hovered elements that needs to be cleared

++     // Send exit event to object pickers on which we

++     // had set the hovered flag for a previous frame

++     // and that aren't being hovered any longer

++     clearPreviouslyHoveredPickers();

++     return true;

++ }

++

++ void PickBoundingVolumeJob::processPickEvent(const PickingUtils::PickConfiguration &pickConfiguration, QObject *object, const QMouseEvent *event)

++ {

++     m_hoveredPickersToClear = m_hoveredPickers;

++

++     QPickEvent::Buttons eventButton = QPickEvent::NoButton;

++     int eventButtons = 0;

++     int eventModifiers = QPickEvent::NoModifier;

++

++     setEventButtonAndModifiers(event, eventButton, eventButtons, eventModifiers);

++

++     // For each Viewport / Camera and Area entry

++     for (const PickingUtils::ViewportCameraAreaDetails &vca : pickConfiguration.vcaDetails) {

++         PickingUtils::HitList sphereHits;

++         QRay3D ray = rayForViewportAndCamera(vca, object, event->pos());

++         if (!ray.isValid()) {

++             // An invalid rays is when we've lost our surface or the mouse

++             // has moved out of the viewport In case of a button released

++             // outside of the viewport, we still want to notify the

++             // lastCurrent entity about this.

++             dispatchPickEvents(event, PickingUtils::HitList(), eventButton, eventButtons, eventModifiers, m_renderSettings->pickResultMode(),

++                                vca.viewportNodeId);

++             continue;

++         }

++

++         PickingUtils::HierarchicalEntityPicker entityPicker(ray);

++         entityPicker.setLayerFilterIds(vca.layersFilters);

++

++         if (entityPicker.collectHits(m_manager, m_node)) {

++             if (pickConfiguration.trianglePickingRequested) {

++                 PickingUtils::TriangleCollisionGathererFunctor gathererFunctor;

++                 gathererFunctor.m_frontFaceRequested = pickConfiguration.frontFaceRequested;

++                 gathererFunctor.m_backFaceRequested = pickConfiguration.backFaceRequested;

++                 gathererFunctor.m_manager = m_manager;

++                 gathererFunctor.m_ray = ray;

++                 gathererFunctor.m_entityToPriorityTable = entityPicker.entityToPriorityTable();

++                 Qt3DCore::moveAtEnd(sphereHits, gathererFunctor.computeHits(entityPicker.entities(), m_renderSettings->pickResultMode()));

++             }

++             if (pickConfiguration.edgePickingRequested) {

++                 PickingUtils::LineCollisionGathererFunctor gathererFunctor;

++                 gathererFunctor.m_manager = m_manager;

++                 gathererFunctor.m_ray = ray;

++                 gathererFunctor.m_pickWorldSpaceTolerance = pickConfiguration.pickWorldSpaceTolerance;

++                 gathererFunctor.m_entityToPriorityTable = entityPicker.entityToPriorityTable();

++                 Qt3DCore::moveAtEnd(sphereHits, gathererFunctor.computeHits(entityPicker.entities(), m_renderSettings->pickResultMode()));

++                 PickingUtils::AbstractCollisionGathererFunctor::sortHits(sphereHits);

++             }

++             if (pickConfiguration.pointPickingRequested) {

++                 PickingUtils::PointCollisionGathererFunctor gathererFunctor;

++                 gathererFunctor.m_manager = m_manager;

++                 gathererFunctor.m_ray = ray;

++                 gathererFunctor.m_pickWorldSpaceTolerance = pickConfiguration.pickWorldSpaceTolerance;

++                 gathererFunctor.m_entityToPriorityTable = entityPicker.entityToPriorityTable();

++                 Qt3DCore::moveAtEnd(sphereHits, gathererFunctor.computeHits(entityPicker.entities(), m_renderSettings->pickResultMode()));

++                 PickingUtils::AbstractCollisionGathererFunctor::sortHits(sphereHits);

++             }

++             if (!pickConfiguration.primitivePickingRequested) {

++                 Qt3DCore::moveAtEnd(sphereHits, entityPicker.hits());

++                 PickingUtils::AbstractCollisionGathererFunctor::sortHits(sphereHits);

++                 if (m_renderSettings->pickResultMode() != QPickingSettings::AllPicks)

++                     sphereHits = { sphereHits.front() };

++             }

++         }

++

++         // Dispatch events based on hit results

++         dispatchPickEvents(event, sphereHits, eventButton, eventButtons, eventModifiers, m_renderSettings->pickResultMode(),

++                            vca.viewportNodeId);

++     }

++ }

++

++ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent *event,

++                                                const PickingUtils::HitList &sphereHits,

++                                                QPickEvent::Buttons eventButton,

++                                                int eventButtons,

++                                                int eventModifiers,

++                                                bool allHitsRequested,

++                                                Qt3DCore::QNodeId viewportNodeId)

++ {

++     Q_D(PickBoundingVolumeJob);

++

++     ObjectPicker *lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);

++     // If we have hits

++     if (!sphereHits.empty()) {

++         // Note: how can we control that we want the first/last/all elements along the ray to be picked

++

++         // How do we differentiate betwnee an Entity with no GeometryRenderer and one with one, both having

++         // an ObjectPicker component when it comes

++

++         for (const QCollisionQueryResult::Hit &hit : std::as_const(sphereHits)) {

++             Entity *entity = m_manager->renderNodesManager()->lookupResource(hit.m_entityId);

++             HObjectPicker objectPickerHandle = entity->componentHandle<ObjectPicker>();

++

++             // If the Entity which actually received the hit doesn't have

++             // an object picker component, we need to check the parent if it has one ...

++             while (objectPickerHandle.isNull() && entity != nullptr) {

++                 entity = entity->parent();

++                 if (entity != nullptr)

++                     objectPickerHandle = entity->componentHandle<ObjectPicker>();

++             }

++

++             ObjectPicker *objectPicker = m_manager->objectPickerManager()->data(objectPickerHandle);

++             if (objectPicker != nullptr && objectPicker->isEnabled()) {

++

++                 if (lastCurrentPicker && !allHitsRequested) {

++                     // if there is a current picker, it will "grab" all events until released.

++                     // Clients should test that entity is what they expect (or only use

++                     // world coordinates)

++                     objectPicker = lastCurrentPicker;

++                 }

++

++                 // Send the corresponding event

++                 Vector3D localIntersection = hit.m_intersection;

++                 if (entity && entity->worldTransform())

++                     localIntersection = entity->worldTransform()->inverted().map(hit.m_intersection);

++

++                 QPickEventPtr pickEvent;

++                 const auto eventPos = event->position();

++                 switch (hit.m_type) {

++                 case QCollisionQueryResult::Hit::Triangle:

++                     pickEvent.reset(new QPickTriangleEvent(eventPos,

++                                                            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.reset(new QPickLineEvent(eventPos,

++                                                        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.reset(new QPickPointEvent(eventPos,

++                                                         convertToQVector3D(hit.m_intersection),

++                                                         convertToQVector3D(localIntersection),

++                                                         hit.m_distance,

++                                                         hit.m_vertexIndex[0],

++                                                         eventButton, eventButtons, eventModifiers));

++                     break;

++                 case QCollisionQueryResult::Hit::Entity:

++                     pickEvent.reset(new QPickEvent(eventPos,

++                                                    convertToQVector3D(hit.m_intersection),

++                                                    convertToQVector3D(localIntersection),

++                                                    hit.m_distance,

++                                                    eventButton, eventButtons, eventModifiers));

++                     break;

++                 default:

++                     Q_UNREACHABLE();

++                 }

++                 Qt3DRender::QPickEventPrivate::get(pickEvent.data())->m_entity = hit.m_entityId;

++                 switch (event->type()) {

++                 case QEvent::MouseButtonPress: {

++                     // Store pressed object handle

++                     m_currentPicker = objectPickerHandle;

++                     m_currentViewport = viewportNodeId;

++                     // Send pressed event to m_currentPicker

++                     d->dispatches.push_back({objectPicker->peerId(), event->type(), pickEvent, viewportNodeId});

++                     objectPicker->setPressed(true);

++                     break;

++                 }

++

++                 case QEvent::MouseButtonRelease: {

++                     // Only send the release event if it was pressed

++                     if (objectPicker->isPressed()) {

++                         d->dispatches.push_back({objectPicker->peerId(), event->type(), pickEvent, viewportNodeId});

++                         objectPicker->setPressed(false);

++                     }

++                     if (lastCurrentPicker != nullptr && m_currentPicker == objectPickerHandle) {

++                         d->dispatches.push_back({objectPicker->peerId(),

++                                                  PickBoundingVolumeJobPrivate::MouseButtonClick,

++                                                  pickEvent, viewportNodeId});

++                         m_currentPicker = HObjectPicker();

++                         m_currentViewport = {};

++                     }

++                     break;

++                 }

++ #if QT_CONFIG(gestures)

++                 case QEvent::Gesture: {

++                     d->dispatches.push_back({objectPicker->peerId(),

++                                              PickBoundingVolumeJobPrivate::MouseButtonClick,

++                                              pickEvent, viewportNodeId});

++                     break;

++                 }

++ #endif

++                 case QEvent::MouseMove: {

++                     if ((objectPicker->isPressed() || objectPicker->isHoverEnabled()) && objectPicker->isDragEnabled())

++                         d->dispatches.push_back({objectPicker->peerId(), event->type(), pickEvent, viewportNodeId});

++                     Q_FALLTHROUGH(); // fallthrough

++                 }

++                 case QEvent::HoverMove: {

++                     if (!m_hoveredPickers.contains(objectPickerHandle)) {

++                         if (objectPicker->isHoverEnabled()) {

++                             // Send entered event to objectPicker

++                             d->dispatches.push_back({objectPicker->peerId(), QEvent::Enter, pickEvent, viewportNodeId});

++                             // and save it in the hoveredPickers

++                             m_hoveredPickers.push_back(objectPickerHandle);

++                         }

++                     }

++                     break;

++                 }

++

++                 default:

++                     break;

++                 }

++             }

++

++             // The ObjectPicker was hit -> it is still being hovered

++             m_hoveredPickersToClear.removeAll(objectPickerHandle);

++

++             lastCurrentPicker = m_manager->objectPickerManager()->data(m_currentPicker);

++         }

++

++         // Otherwise no hits

++     } else {

++         switch (event->type()) {

++         case QEvent::MouseButtonRelease: {

++             // Send release event to m_currentPicker

++             if (lastCurrentPicker != nullptr && m_currentViewport == viewportNodeId) {

++                 m_currentPicker = HObjectPicker();

++                 m_currentViewport = {};

++                 QPickEventPtr pickEvent(new QPickEvent);

++                 lastCurrentPicker->setPressed(false);

++                 d->dispatches.push_back({lastCurrentPicker->peerId(), event->type(), pickEvent, viewportNodeId});

++             }

++             break;

++         }

++         default:

++             break;

++         }

++     }

++ }

++

++ void PickBoundingVolumeJob::clearPreviouslyHoveredPickers()

++ {

++     Q_D(PickBoundingVolumeJob);

++

++     for (const HObjectPicker &pickHandle : std::as_const(m_hoveredPickersToClear)) {

++         ObjectPicker *pick = m_manager->objectPickerManager()->data(pickHandle);

++         if (pick)

++             d->dispatches.push_back({pick->peerId(), QEvent::Leave, {}, {}});

++         m_hoveredPickers.removeAll(pickHandle);

++     }

++

++     m_hoveredPickersToClear.clear();

++ }

++

++ } // namespace Render

++

++ } // namespace Qt3DRender

++

++ QT_END_NAMESPACE

Revision control