diff options
22 files changed, 948 insertions, 115 deletions
diff --git a/.qmake.conf b/.qmake.conf index f690718eb..32d61d9d4 100644 --- a/.qmake.conf +++ b/.qmake.conf @@ -6,4 +6,4 @@ load(qt_build_config) DEFINES += QT_NO_FOREACH DEFINES += QT_NO_JAVA_STYLE_ITERATORS -MODULE_VERSION = 5.15.5 +MODULE_VERSION = 5.15.6 diff --git a/src/animation/frontend/qkeyframe.h b/src/animation/frontend/qkeyframe.h index 87e2812b2..a05e446dd 100644 --- a/src/animation/frontend/qkeyframe.h +++ b/src/animation/frontend/qkeyframe.h @@ -47,7 +47,7 @@ QT_BEGIN_NAMESPACE namespace Qt3DAnimation { -class Q_3DANIMATIONSHARED_EXPORT QKeyFrame +class QKeyFrame { public: enum InterpolationType : quint8 { diff --git a/src/plugins/renderers/opengl/graphicshelpers/graphicshelpergl4.cpp b/src/plugins/renderers/opengl/graphicshelpers/graphicshelpergl4.cpp index f23dd8485..a472da774 100644 --- a/src/plugins/renderers/opengl/graphicshelpers/graphicshelpergl4.cpp +++ b/src/plugins/renderers/opengl/graphicshelpers/graphicshelpergl4.cpp @@ -634,6 +634,7 @@ UniformType GraphicsHelperGL4::uniformTypeFromGLType(GLenum type) case GL_SAMPLER_1D: case GL_SAMPLER_1D_ARRAY: case GL_SAMPLER_1D_SHADOW: + case GL_SAMPLER_1D_ARRAY_SHADOW: case GL_SAMPLER_2D: case GL_SAMPLER_2D_RECT: case GL_SAMPLER_2D_SHADOW: @@ -652,6 +653,7 @@ UniformType GraphicsHelperGL4::uniformTypeFromGLType(GLenum type) case GL_INT_SAMPLER_2D: case GL_INT_SAMPLER_3D: case GL_INT_SAMPLER_BUFFER: + case GL_INT_SAMPLER_2D_RECT: case GL_INT_SAMPLER_CUBE: case GL_INT_SAMPLER_CUBE_MAP_ARRAY: case GL_INT_SAMPLER_1D_ARRAY: @@ -662,6 +664,7 @@ UniformType GraphicsHelperGL4::uniformTypeFromGLType(GLenum type) case GL_UNSIGNED_INT_SAMPLER_2D: case GL_UNSIGNED_INT_SAMPLER_3D: case GL_UNSIGNED_INT_SAMPLER_BUFFER: + case GL_UNSIGNED_INT_SAMPLER_2D_RECT: case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: @@ -1078,17 +1081,21 @@ void GraphicsHelperGL4::buildUniformBuffer(const QVariant &v, const ShaderUnifor case GL_INT_SAMPLER_2D: case GL_INT_SAMPLER_3D: case GL_INT_SAMPLER_CUBE: + case GL_INT_SAMPLER_CUBE_MAP_ARRAY: case GL_INT_SAMPLER_BUFFER: case GL_INT_SAMPLER_2D_RECT: case GL_UNSIGNED_INT_SAMPLER_1D: case GL_UNSIGNED_INT_SAMPLER_2D: case GL_UNSIGNED_INT_SAMPLER_3D: case GL_UNSIGNED_INT_SAMPLER_CUBE: + case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: case GL_UNSIGNED_INT_SAMPLER_BUFFER: case GL_UNSIGNED_INT_SAMPLER_2D_RECT: case GL_SAMPLER_1D_SHADOW: case GL_SAMPLER_2D_SHADOW: case GL_SAMPLER_CUBE_SHADOW: + case GL_SAMPLER_CUBE_MAP_ARRAY: + case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: case GL_SAMPLER_1D_ARRAY: case GL_SAMPLER_2D_ARRAY: case GL_INT_SAMPLER_1D_ARRAY: @@ -1251,6 +1258,10 @@ uint GraphicsHelperGL4::uniformByteSize(const ShaderUniform &description) case GL_SAMPLER_1D_SHADOW: case GL_SAMPLER_2D_SHADOW: case GL_SAMPLER_CUBE_SHADOW: + case GL_SAMPLER_CUBE_MAP_ARRAY: + case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: + case GL_INT_SAMPLER_CUBE_MAP_ARRAY: + case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: case GL_SAMPLER_1D_ARRAY: case GL_SAMPLER_2D_ARRAY: case GL_INT_SAMPLER_1D_ARRAY: diff --git a/src/quick3d/imports/scene3d/scene3ditem.cpp b/src/quick3d/imports/scene3d/scene3ditem.cpp index 377569f6a..126680595 100644 --- a/src/quick3d/imports/scene3d/scene3ditem.cpp +++ b/src/quick3d/imports/scene3d/scene3ditem.cpp @@ -219,6 +219,7 @@ Scene3DItem::Scene3DItem(QQuickItem *parent) , m_cameraAspectRatioMode(AutomaticAspectRatio) , m_compositingMode(FBO) , m_dummySurface(nullptr) + , m_framesToRender(ms_framesNeededToFlushPipeline) { setFlag(QQuickItem::ItemHasContents, true); setAcceptedMouseButtons(Qt::MouseButtonMask); @@ -542,8 +543,13 @@ bool Scene3DItem::needsRender(QRenderAspect *renderAspect) || (renderAspectPriv && renderAspectPriv->m_renderer && renderAspectPriv->m_renderer->shouldRender()); - m_dirty = false; - return dirty; + + if (m_dirty) { + --m_framesToRender; + if (m_framesToRender <= 0) + m_dirty = false; + } + return dirty || m_framesToRender > 0; } // This function is triggered in the context of the Main Thread @@ -911,15 +917,16 @@ QSGNode *Scene3DItem::updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNode updateWindowSurface(); managerNode->init(); // Note: ChangeArbiter is only set after aspect was registered - - // This allows Scene3DItem to know when it needs to re-render as a result of frontend nodes receiving a change. - QObject::connect(renderAspectPriv->m_aspectManager->changeArbiter(), &Qt3DCore::QChangeArbiter::receivedChange, - this, [this] { m_dirty = true; }, Qt::DirectConnection); - - // This allows Scene3DItem to know when it needs to re-render as a result of backend nodes receiving a change. - // For e.g. nodes being created/destroyed. - QObject::connect(renderAspectPriv->m_aspectManager->changeArbiter(), &Qt3DCore::QChangeArbiter::syncedChanges, - this, [this] { m_dirty = true; }, Qt::QueuedConnection); + QObject::connect( + renderAspectPriv->m_aspectManager->changeArbiter(), + &Qt3DCore::QChangeArbiter::receivedChange, this, + [this] { + m_dirty = true; + m_framesToRender = ms_framesNeededToFlushPipeline; + }, + Qt::DirectConnection); + // Give the window a nudge to trigger an update. + QMetaObject::invokeMethod(window(), "requestUpdate", Qt::QueuedConnection); } const bool usesFBO = m_compositingMode == FBO; diff --git a/src/quick3d/imports/scene3d/scene3ditem_p.h b/src/quick3d/imports/scene3d/scene3ditem_p.h index 4a939aaab..3a6ca5007 100644 --- a/src/quick3d/imports/scene3d/scene3ditem_p.h +++ b/src/quick3d/imports/scene3d/scene3ditem_p.h @@ -169,6 +169,9 @@ private: QOffscreenSurface *m_dummySurface; QVector<Scene3DView *> m_views; QMetaObject::Connection m_windowConnection; + qint8 m_framesToRender; + + static const qint8 ms_framesNeededToFlushPipeline = 2; }; } // Qt3DRender diff --git a/src/render/backend/cameralens.cpp b/src/render/backend/cameralens.cpp index 9b8d7d710..743749210 100644 --- a/src/render/backend/cameralens.cpp +++ b/src/render/backend/cameralens.cpp @@ -133,12 +133,12 @@ void CameraLens::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTim const Matrix4x4 projectionMatrix(node->projectionMatrix()); if (projectionMatrix != m_projection) { m_projection = projectionMatrix; - markDirty(AbstractRenderer::AllDirty); + markDirty(AbstractRenderer::ParameterDirty); } if (!qFuzzyCompare(node->exposure(), m_exposure)) { m_exposure = node->exposure(); - markDirty(AbstractRenderer::AllDirty); + markDirty(AbstractRenderer::ParameterDirty); } const QCameraLensPrivate *d = static_cast<const QCameraLensPrivate *>(QNodePrivate::get(node)); diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp index 4e8967e6e..bbf1013d9 100644 --- a/src/render/frontend/qrenderaspect.cpp +++ b/src/render/frontend/qrenderaspect.cpp @@ -322,7 +322,9 @@ QRenderAspectPrivate::QRenderAspectPrivate(QRenderAspect::RenderType type) m_expandBoundingVolumeJob->addDependency(m_updateWorldBoundingVolumeJob); m_updateLevelOfDetailJob->addDependency(m_expandBoundingVolumeJob); m_pickBoundingVolumeJob->addDependency(m_expandBoundingVolumeJob); + m_pickBoundingVolumeJob->addDependency(m_updateEntityLayersJob); m_rayCastingJob->addDependency(m_expandBoundingVolumeJob); + m_rayCastingJob->addDependency(m_updateEntityLayersJob); } /*! \internal */ @@ -717,17 +719,20 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time) if (entitiesEnabledDirty) jobs.push_back(d->m_updateTreeEnabledJob); - if (dirtyBitsForFrame & AbstractRenderer::TransformDirty) { + if (entitiesEnabledDirty || + dirtyBitsForFrame & AbstractRenderer::TransformDirty) { jobs.push_back(d->m_worldTransformJob); jobs.push_back(d->m_updateWorldBoundingVolumeJob); } - if (dirtyBitsForFrame & AbstractRenderer::GeometryDirty || + if (entitiesEnabledDirty || + dirtyBitsForFrame & AbstractRenderer::GeometryDirty || dirtyBitsForFrame & AbstractRenderer::BuffersDirty) { jobs.push_back(d->m_calculateBoundingVolumeJob); } - if (dirtyBitsForFrame & AbstractRenderer::GeometryDirty || + if (entitiesEnabledDirty || + dirtyBitsForFrame & AbstractRenderer::GeometryDirty || dirtyBitsForFrame & AbstractRenderer::TransformDirty) { jobs.push_back(d->m_expandBoundingVolumeJob); } diff --git a/src/render/jobs/filterlayerentityjob.cpp b/src/render/jobs/filterlayerentityjob.cpp index ae3cced59..401bbc148 100644 --- a/src/render/jobs/filterlayerentityjob.cpp +++ b/src/render/jobs/filterlayerentityjob.cpp @@ -75,6 +75,33 @@ void FilterLayerEntityJob::run() std::sort(m_filteredEntities.begin(), m_filteredEntities.end()); } +void FilterLayerEntityJob::filterEntityAgainstLayers(Entity *entity, + const Qt3DCore::QNodeIdVector &layerIds, + const QLayerFilter::FilterMode filterMode) +{ + // Perform filtering + switch (filterMode) { + case QLayerFilter::AcceptAnyMatchingLayers: { + filterAcceptAnyMatchingLayers(entity, layerIds); + break; + } + case QLayerFilter::AcceptAllMatchingLayers: { + filterAcceptAllMatchingLayers(entity, layerIds); + break; + } + case QLayerFilter::DiscardAnyMatchingLayers: { + filterDiscardAnyMatchingLayers(entity, layerIds); + break; + } + case QLayerFilter::DiscardAllMatchingLayers: { + filterDiscardAllMatchingLayers(entity, layerIds); + break; + } + default: + Q_UNREACHABLE(); + } +} + // We accept the entity if it contains any of the layers that are in the layer filter void FilterLayerEntityJob::filterAcceptAnyMatchingLayers(Entity *entity, const Qt3DCore::QNodeIdVector &layerIds) @@ -181,28 +208,8 @@ void FilterLayerEntityJob::filterLayerAndEntity() const QLayerFilter::FilterMode filterMode = layerFilter->filterMode(); // Perform filtering - for (Entity *entity : entitiesToFilter) { - switch (filterMode) { - case QLayerFilter::AcceptAnyMatchingLayers: { - filterAcceptAnyMatchingLayers(entity, layerIds); - break; - } - case QLayerFilter::AcceptAllMatchingLayers: { - filterAcceptAllMatchingLayers(entity, layerIds); - break; - } - case QLayerFilter::DiscardAnyMatchingLayers: { - filterDiscardAnyMatchingLayers(entity, layerIds); - break; - } - case QLayerFilter::DiscardAllMatchingLayers: { - filterDiscardAllMatchingLayers(entity, layerIds); - break; - } - default: - Q_UNREACHABLE(); - } - } + for (Entity *entity : entitiesToFilter) + filterEntityAgainstLayers(entity, layerIds, filterMode); // Entities to filter for the next frame are the filtered result of the // current LayerFilter diff --git a/src/render/jobs/filterlayerentityjob_p.h b/src/render/jobs/filterlayerentityjob_p.h index 33023775f..6e8636f28 100644 --- a/src/render/jobs/filterlayerentityjob_p.h +++ b/src/render/jobs/filterlayerentityjob_p.h @@ -80,6 +80,7 @@ public: // QAspectJob interface void run() final; + void filterEntityAgainstLayers(Entity *entity, const Qt3DCore::QNodeIdVector &layerIds, const QLayerFilter::FilterMode filterMode); void filterAcceptAnyMatchingLayers(Entity *entity, const Qt3DCore::QNodeIdVector &layerIds); void filterAcceptAllMatchingLayers(Entity *entity, const Qt3DCore::QNodeIdVector &layerIds); void filterDiscardAnyMatchingLayers(Entity *entity, const Qt3DCore::QNodeIdVector &layerIds); diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp index eebacc681..7519cbd9c 100644 --- a/src/render/jobs/pickboundingvolumejob.cpp +++ b/src/render/jobs/pickboundingvolumejob.cpp @@ -330,6 +330,7 @@ bool PickBoundingVolumeJob::runHelper() } PickingUtils::HierarchicalEntityPicker entityPicker(ray); + entityPicker.setLayerFilterIds(vca.layersFilters); if (entityPicker.collectHits(m_manager, m_node)) { if (trianglePickingRequested) { PickingUtils::TriangleCollisionGathererFunctor gathererFunctor; @@ -472,6 +473,7 @@ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent &event, 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); @@ -489,6 +491,7 @@ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent &event, PickBoundingVolumeJobPrivate::MouseButtonClick, pickEvent, viewportNodeId}); m_currentPicker = HObjectPicker(); + m_currentViewport = {}; } break; } @@ -533,8 +536,9 @@ void PickBoundingVolumeJob::dispatchPickEvents(const QMouseEvent &event, switch (event.type()) { case QEvent::MouseButtonRelease: { // Send release event to m_currentPicker - if (lastCurrentPicker != nullptr) { + 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}); diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h index 4f2c4340e..286bbb051 100644 --- a/src/render/jobs/pickboundingvolumejob_p.h +++ b/src/render/jobs/pickboundingvolumejob_p.h @@ -112,6 +112,7 @@ private: bool m_pickersDirty; bool m_oneHoverAtLeast; HObjectPicker m_currentPicker; + Qt3DCore::QNodeId m_currentViewport; QVector<HObjectPicker> m_hoveredPickers; QVector<HObjectPicker> m_hoveredPickersToClear; }; diff --git a/src/render/jobs/pickboundingvolumeutils.cpp b/src/render/jobs/pickboundingvolumeutils.cpp index 1d22e8645..f4c5cc094 100644 --- a/src/render/jobs/pickboundingvolumeutils.cpp +++ b/src/render/jobs/pickboundingvolumeutils.cpp @@ -52,6 +52,9 @@ #include <Qt3DRender/private/segmentsvisitor_p.h> #include <Qt3DRender/private/pointsvisitor_p.h> #include <Qt3DRender/private/layer_p.h> +#include <Qt3DRender/private/layerfilternode_p.h> +#include <Qt3DRender/private/rendersettings_p.h> +#include <Qt3DRender/private/filterlayerentityjob_p.h> #include <vector> #include <algorithm> @@ -105,6 +108,11 @@ ViewportCameraAreaDetails ViewportCameraAreaGatherer::gatherUpViewportCameraArea // prevent picking in the presence of a NoPicking node return {}; } + case FrameGraphNode::LayerFilter: { + auto fnode = static_cast<const LayerFilterNode *>(node); + vca.layersFilters.push_back(fnode->peerId()); + break; + } default: break; } @@ -139,7 +147,8 @@ bool ViewportCameraAreaGatherer::isUnique(const QVector<ViewportCameraAreaDetail if (vca.cameraId == listItem.cameraId && vca.viewport == listItem.viewport && vca.surface == listItem.surface && - vca.area == listItem.area) + vca.area == listItem.area && + vca.layersFilters == listItem.layersFilters) return false; } return true; @@ -700,16 +709,19 @@ HitList PointCollisionGathererFunctor::pick(const Entity *entity) const HierarchicalEntityPicker::HierarchicalEntityPicker(const QRay3D &ray, bool requireObjectPicker) : m_ray(ray) , m_objectPickersRequired(requireObjectPicker) - , m_filterMode(QAbstractRayCaster::AcceptAnyMatchingLayers) { +} +void HierarchicalEntityPicker::setLayerFilterIds(const Qt3DCore::QNodeIdVector &layerFilterIds) +{ + m_layerFilterIds = layerFilterIds; } -void HierarchicalEntityPicker::setFilterLayers(const Qt3DCore::QNodeIdVector &layerIds, QAbstractRayCaster::FilterMode mode) +void HierarchicalEntityPicker::setLayerIds(const Qt3DCore::QNodeIdVector &layerIds, + QAbstractRayCaster::FilterMode mode) { - m_filterMode = mode; m_layerIds = layerIds; - std::sort(m_layerIds.begin(), m_layerIds.end()); + m_layerFilterMode = mode; } bool HierarchicalEntityPicker::collectHits(NodeManagers *manager, Entity *root) @@ -722,60 +734,37 @@ bool HierarchicalEntityPicker::collectHits(NodeManagers *manager, Entity *root) struct EntityData { Entity* entity; bool hasObjectPicker; - Qt3DCore::QNodeIdVector recursiveLayers; int priority; }; std::vector<EntityData> worklist; - worklist.push_back({root, !root->componentHandle<ObjectPicker>().isNull(), {}, 0}); - - LayerManager *layerManager = manager->layerManager(); + worklist.push_back({root, !root->componentHandle<ObjectPicker>().isNull(), 0}); + + // Record all entities that satisfy layerFiltering. We can then check against + // that to see if a picked Entity also satisfies the layer filtering + + // Note: PickBoundingVolumeJob filters against LayerFilter nodes (FG) whereas + // the RayCastingJob filters only against a set of Layers and a filter Mode + const bool hasLayerFilters = m_layerFilterIds.size() > 0; + const bool hasLayers = m_layerIds.size() > 0; + const bool hasLayerFiltering = hasLayerFilters || hasLayers; + QVector<Entity *> layerFilterEntities; + FilterLayerEntityJob layerFilterJob; + layerFilterJob.setManager(manager); + + if (hasLayerFilters) { + // Note: we expect UpdateEntityLayersJob was called beforehand to handle layer recursivness + // Filtering against LayerFilters (PickBoundingVolumeJob) + if (m_layerFilterIds.size()) { + layerFilterJob.setLayerFilters(m_layerFilterIds); + layerFilterJob.run(); + layerFilterEntities = layerFilterJob.filteredEntities(); + } + } while (!worklist.empty()) { EntityData current = worklist.back(); worklist.pop_back(); - bool accepted = true; - if (m_layerIds.size()) { - // TODO investigate reusing logic from LayerFilter job - Qt3DCore::QNodeIdVector filterLayers = current.recursiveLayers + current.entity->componentsUuid<Layer>(); - - // remove disabled layers - filterLayers.erase(std::remove_if(filterLayers.begin(), filterLayers.end(), - [layerManager](const Qt3DCore::QNodeId layerId) { - Layer *layer = layerManager->lookupResource(layerId); - return !layer || !layer->isEnabled(); - }), filterLayers.end()); - - std::sort(filterLayers.begin(), filterLayers.end()); - - Qt3DCore::QNodeIdVector commonIds; - std::set_intersection(m_layerIds.cbegin(), m_layerIds.cend(), - filterLayers.cbegin(), filterLayers.cend(), - std::back_inserter(commonIds)); - - switch (m_filterMode) { - case QAbstractRayCaster::AcceptAnyMatchingLayers: { - accepted = !commonIds.empty(); - break; - } - case QAbstractRayCaster::AcceptAllMatchingLayers: { - accepted = commonIds == m_layerIds; - break; - } - case QAbstractRayCaster::DiscardAnyMatchingLayers: { - accepted = commonIds.empty(); - break; - } - case QAbstractRayCaster::DiscardAllMatchingLayers: { - accepted = !(commonIds == m_layerIds); - break; - } - default: - Q_UNREACHABLE(); - break; - } - } - // first pick entry sub-scene-graph QCollisionQueryResult::Hit queryResult = rayCasting.query(m_ray, current.entity->worldBoundingVolumeWithChildren()); @@ -784,21 +773,27 @@ bool HierarchicalEntityPicker::collectHits(NodeManagers *manager, Entity *root) // if we get a hit, we check again for this specific entity queryResult = rayCasting.query(m_ray, current.entity->worldBoundingVolume()); - if (accepted && queryResult.m_distance >= 0.f && (current.hasObjectPicker || !m_objectPickersRequired)) { + + // Check Entity is in selected Layers if we have LayerIds or LayerFilterIds + // Note: it's not because a parent doesn't satisfy the layerFiltering that a child might not. + // Therefore we need to keep traversing children in all cases + + // Are we filtering against layerIds (RayCastingJob) + if (hasLayers) { + // QLayerFilter::FilterMode and QAbstractRayCaster::FilterMode are the same + layerFilterJob.filterEntityAgainstLayers(current.entity, m_layerIds, static_cast<QLayerFilter::FilterMode>(m_layerFilterMode)); + layerFilterEntities = layerFilterJob.filteredEntities(); + } + + const bool isInLayers = !hasLayerFiltering || layerFilterEntities.contains(current.entity); + + if (isInLayers && queryResult.m_distance >= 0.f && (current.hasObjectPicker || !m_objectPickersRequired)) { m_entities.push_back(current.entity); m_hits.push_back(queryResult); // Record entry for entity/priority m_entityToPriorityTable.insert(current.entity->peerId(), current.priority); } - Qt3DCore::QNodeIdVector recursiveLayers; - const Qt3DCore::QNodeIdVector entityLayers = current.entity->componentsUuid<Layer>(); - for (const Qt3DCore::QNodeId layerId : entityLayers) { - Layer *layer = layerManager->lookupResource(layerId); - if (layer->recursive()) - recursiveLayers << layerId; - } - // and pick children const auto childrenHandles = current.entity->childrenHandles(); for (const HEntity &handle : childrenHandles) { @@ -806,7 +801,6 @@ bool HierarchicalEntityPicker::collectHits(NodeManagers *manager, Entity *root) if (child) { ObjectPicker *childPicker = child->renderComponent<ObjectPicker>(); worklist.push_back({child, current.hasObjectPicker || childPicker, - current.recursiveLayers + recursiveLayers, (childPicker ? childPicker->priority() : current.priority)}); } } diff --git a/src/render/jobs/pickboundingvolumeutils_p.h b/src/render/jobs/pickboundingvolumeutils_p.h index fa3e701c2..1fe81fc46 100644 --- a/src/render/jobs/pickboundingvolumeutils_p.h +++ b/src/render/jobs/pickboundingvolumeutils_p.h @@ -83,8 +83,9 @@ struct Q_AUTOTEST_EXPORT ViewportCameraAreaDetails QRectF viewport; QSize area; QSurface *surface = nullptr; + Qt3DCore::QNodeIdVector layersFilters; }; -QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, PickingUtils, ViewportCameraAreaDetails, Q_PRIMITIVE_TYPE) +QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, PickingUtils, ViewportCameraAreaDetails, Q_COMPLEX_TYPE) class Q_AUTOTEST_EXPORT ViewportCameraAreaGatherer { @@ -108,7 +109,8 @@ class Q_AUTOTEST_EXPORT HierarchicalEntityPicker public: explicit HierarchicalEntityPicker(const RayCasting::QRay3D &ray, bool requireObjectPicker = true); - void setFilterLayers(const Qt3DCore::QNodeIdVector &layerIds, QAbstractRayCaster::FilterMode mode); + void setLayerFilterIds(const Qt3DCore::QNodeIdVector &layerFilterIds); + void setLayerIds(const Qt3DCore::QNodeIdVector &layerIds, QAbstractRayCaster::FilterMode mode); bool collectHits(NodeManagers *manager, Entity *root); inline HitList hits() const { return m_hits; } @@ -120,8 +122,9 @@ private: HitList m_hits; QVector<Entity *> m_entities; bool m_objectPickersRequired; + Qt3DCore::QNodeIdVector m_layerFilterIds; Qt3DCore::QNodeIdVector m_layerIds; - QAbstractRayCaster::FilterMode m_filterMode; + QAbstractRayCaster::FilterMode m_layerFilterMode = QAbstractRayCaster::AcceptAnyMatchingLayers; QHash<Qt3DCore::QNodeId, int> m_entityToPriorityTable; }; diff --git a/src/render/jobs/raycastingjob.cpp b/src/render/jobs/raycastingjob.cpp index b7d4c4b7c..56f681a2c 100644 --- a/src/render/jobs/raycastingjob.cpp +++ b/src/render/jobs/raycastingjob.cpp @@ -202,7 +202,7 @@ bool RayCastingJob::runHelper() for (const QRay3D &ray: qAsConst(rays)) { PickingUtils::HitList sphereHits; PickingUtils::HierarchicalEntityPicker entityPicker(ray, false); - entityPicker.setFilterLayers(pair.second->layerIds(), pair.second->filterMode()); + entityPicker.setLayerIds(pair.second->layerIds(), pair.second->filterMode()); if (entityPicker.collectHits(m_manager, m_node)) { if (trianglePickingRequested) { PickingUtils::TriangleCollisionGathererFunctor gathererFunctor; diff --git a/src/render/shadergraph/qshadernode.cpp b/src/render/shadergraph/qshadernode.cpp index e0421e006..56c9961f3 100644 --- a/src/render/shadergraph/qshadernode.cpp +++ b/src/render/shadergraph/qshadernode.cpp @@ -152,11 +152,15 @@ QVector<QShaderFormat> QShaderNode::availableFormats() const QShaderNode::Rule QShaderNode::rule(const QShaderFormat &format) const { - const auto it = std::find_if(m_rules.crbegin(), m_rules.crend(), - [format](const QPair<QShaderFormat, Rule> &entry) { - return format.supports(entry.first); - }); - return it != m_rules.crend() ? it->second : Rule(); + const QPair<QShaderFormat, Rule> *selected = nullptr; + for (auto it = m_rules.crbegin(); it != m_rules.crend(); ++it) { + const auto &entry = *it; + if (format.supports(entry.first)) { + if (!selected || entry.first.version() > selected->first.version()) + selected = &entry; + } + } + return selected ? selected->second : Rule(); } QShaderNode::Rule::Rule(const QByteArray &subs, const QByteArrayList &snippets) noexcept diff --git a/tests/auto/render/aspect/tst_aspect.cpp b/tests/auto/render/aspect/tst_aspect.cpp index 9bd5df698..5d0ead7ef 100644 --- a/tests/auto/render/aspect/tst_aspect.cpp +++ b/tests/auto/render/aspect/tst_aspect.cpp @@ -139,6 +139,10 @@ private Q_SLOTS: // THEN -> enabled dirty QCOMPARE(jobs.size(), 1 + // UpdateTreeEnabled + 1 + // UpdateTransform + 1 + // UpdateWorldBoundingVolume + 1 + // CalcBoundingVolume + 1 + // ExpandBoundingVolume 1 + // SyncLoadingJobs 1 + // UpdateSkinningPalette 1 + // UpdateLevelOfDetail diff --git a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc index 76150da31..df0198f76 100644 --- a/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc +++ b/tests/auto/render/pickboundingvolumejob/pickboundingvolumejob.qrc @@ -12,5 +12,7 @@ <file>testscene_cameraposition.qml</file> <file>testscene_priorityoverlapping.qml</file> <file>testscene_nopicking.qml</file> + <file>testscene_layerfilter.qml</file> + <file>testscene_nested_layerfilter.qml</file> </qresource> </RCC> diff --git a/tests/auto/render/pickboundingvolumejob/testscene_layerfilter.qml b/tests/auto/render/pickboundingvolumejob/testscene_layerfilter.qml new file mode 100644 index 000000000..392623a6a --- /dev/null +++ b/tests/auto/render/pickboundingvolumejob/testscene_layerfilter.qml @@ -0,0 +1,162 @@ +/**************************************************************************** +** +** Copyright (C) 2021 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.0 +import Qt3D.Extras 2.0 +import QtQuick.Window 2.0 + +Entity { + id: sceneRoot + + Window { + id: _view + width: 600 + height: 600 + visible: true + } + + Camera { + id: camera + projectionType: CameraLens.PerspectiveProjection + fieldOfView: 45 + aspectRatio: _view.width / 2 / _view.height + nearPlane : 0.1 + farPlane : 1000.0 + position: Qt.vector3d( 0.0, 0.0, -10.0 ) + upVector: Qt.vector3d( 0.0, 1.0, 0.0 ) + viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 ) + } + + Camera { + id: camera2 + projectionType: CameraLens.PerspectiveProjection + fieldOfView: 45 + aspectRatio: _view.width / 2 / _view.height + nearPlane : 0.1 + farPlane : 1000.0 + position: Qt.vector3d( 0.0, 0.0, -10.0 ) + upVector: Qt.vector3d( 0.0, 1.0, 0.0 ) + viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 ) + } + + FirstPersonCameraController { + camera: camera + } + + DirectionalLight { + worldDirection: camera.viewVector.times(-1) + } + + // Draw 2 viewports + components: [ + RenderSettings { + RenderSurfaceSelector { + surface: _view + + Viewport { + normalizedRect: Qt.rect(0.0, 0.0, 0.5, 1.0) + ClearBuffers { + buffers : ClearBuffers.ColorDepthBuffer + clearColor: "white" + CameraSelector { + camera: camera + + LayerFilter { + layers: [ layer1 ] + } + } + } + } + + Viewport { + normalizedRect: Qt.rect(0.5, 0.0, 0.5, 1.0) + CameraSelector { + camera: camera2 + + LayerFilter { + layers: [ layer2 ] + } + } + } + } + } + ] + + CuboidMesh { id: cubeMesh } + + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker1" + onClicked: console.log("o1") + } + readonly property Transform transform: Transform { + scale: 4 + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "red" } + readonly property Layer layer: Layer { id: layer1 } + + components: [cubeMesh, transform, material, objectPicker, layer ] + } + + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker2" + onClicked: console.log("o2") + } + readonly property Transform transform: Transform { + scale: 3 + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "green" } + readonly property Layer layer: Layer { id: layer2 } + + components: [cubeMesh, transform, material, objectPicker, layer ] + } +} diff --git a/tests/auto/render/pickboundingvolumejob/testscene_nested_layerfilter.qml b/tests/auto/render/pickboundingvolumejob/testscene_nested_layerfilter.qml new file mode 100644 index 000000000..b913b6f5f --- /dev/null +++ b/tests/auto/render/pickboundingvolumejob/testscene_nested_layerfilter.qml @@ -0,0 +1,233 @@ +/**************************************************************************** +** +** Copyright (C) 2021 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.0 +import Qt3D.Extras 2.0 +import QtQuick.Window 2.0 + +Entity { + id: sceneRoot + + Window { + id: _view + width: 600 + height: 600 + visible: true + } + + Camera { + id: camera + projectionType: CameraLens.PerspectiveProjection + fieldOfView: 45 + aspectRatio: _view.width / 2 / _view.height + nearPlane : 0.1 + farPlane : 1000.0 + position: Qt.vector3d( 0.0, 0.0, -10.0 ) + upVector: Qt.vector3d( 0.0, 1.0, 0.0 ) + viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 ) + } + + Camera { + id: camera2 + projectionType: CameraLens.PerspectiveProjection + fieldOfView: 45 + aspectRatio: _view.width / 2 / _view.height + nearPlane : 0.1 + farPlane : 1000.0 + position: Qt.vector3d( 0.0, 0.0, -10.0 ) + upVector: Qt.vector3d( 0.0, 1.0, 0.0 ) + viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 ) + } + + FirstPersonCameraController { + camera: camera + } + + DirectionalLight { + worldDirection: camera.viewVector.times(-1) + } + + // Draw 2 viewports + components: [ + RenderSettings { + RenderSurfaceSelector { + surface: _view + + Viewport { + normalizedRect: Qt.rect(0.0, 0.0, 0.5, 1.0) + ClearBuffers { + buffers : ClearBuffers.ColorDepthBuffer + clearColor: "red" + CameraSelector { + camera: camera + + LayerFilter { + // Any of + layers: [ layer1, layer3 ] + + LayerFilter { + filterMode: LayerFilter.DiscardAnyMatchingLayers + layers: [layer2] + } + } + } + } + } + + Viewport { + normalizedRect: Qt.rect(0.5, 0.0, 0.5, 1.0) + CameraSelector { + camera: camera2 + + LayerFilter { + layers: [ layerRecursive ] + + LayerFilter { + filterMode: LayerFilter.DiscardAnyMatchingLayers + layers: [layer1] + } + } + } + } + } + + pickingSettings { + pickMethod: PickingSettings.TrianglePicking + } + } + ] + + CuboidMesh { id: cubeMesh } + + Layer { id: layerRecursive; recursive: true } + Layer { id: layer1 } + Layer { id: layer2 } + Layer { id: layer3 } + + Entity { + id: rootSceneEntity + components: [layerRecursive] + + // Selected by Viewport 1 + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker1" + onClicked: console.log("o1 " + pick.position) + } + readonly property Transform transform: Transform { + scale: 2 + translation: Qt.vector3d(-1, 0, 0) + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "red" } + + components: [cubeMesh, transform, material, objectPicker, layer1 ] + } + + // Selected by Viewport 2 + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker2" + onClicked: console.log("o2" + pick.position) + } + readonly property Transform transform: Transform { + scale: 3 + translation: Qt.vector3d(-2, 3, 5) + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "green" } + + components: [cubeMesh, transform, material, objectPicker, layer2 ] + } + + // Not Selected by Any Viewport + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker3" + onClicked: console.log("o3" + pick.position) + } + readonly property Transform transform: Transform { + scale: 4 + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "blue" } + + components: [cubeMesh, transform, material, objectPicker, layer1, layer2 ] + } + + // Both Viewport + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker4" + onClicked: console.log("o4" + pick.position) + } + readonly property Transform transform: Transform { + scale: 1 + translation: Qt.vector3d(0, -2, -1) + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "orange" } + + components: [cubeMesh, transform, material, objectPicker, layer3 ] + } + + // Viewport 1 + Entity { + readonly property ObjectPicker objectPicker: ObjectPicker { + objectName: "Picker5" + onClicked: console.log("o5" + pick.position) + } + readonly property Transform transform: Transform { + scale: 2 + translation: Qt.vector3d(0, 1, 3) + } + readonly property PhongMaterial material: PhongMaterial { diffuse: "purple" } + + components: [cubeMesh, transform, material, objectPicker, layer3, layer1 ] + } + } +} diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp index 0c1ee0183..41afb0ee9 100644 --- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp +++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp @@ -60,6 +60,7 @@ #include <Qt3DRender/private/expandboundingvolumejob_p.h> #include <Qt3DRender/private/calcboundingvolumejob_p.h> #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h> +#include <Qt3DRender/private/updateentitylayersjob_p.h> #include <Qt3DRender/private/loadbufferjob_p.h> #include <Qt3DRender/private/buffermanager_p.h> #include <Qt3DRender/private/geometryrenderermanager_p.h> @@ -215,6 +216,10 @@ void runRequiredJobs(Qt3DRender::TestAspect *test) Qt3DRender::Render::CalcGeometryTriangleVolumes calcGeometryTriangles(geometryRendererId, test->nodeManagers()); calcGeometryTriangles.run(); } + + Qt3DRender::Render::UpdateEntityLayersJob updateEntityLayer; + updateEntityLayer.setManager(test->nodeManagers()); + updateEntityLayer.run(); } void initializePickBoundingVolumeJob(Qt3DRender::Render::PickBoundingVolumeJob *job, Qt3DRender::TestAspect *test) @@ -287,7 +292,6 @@ private: } private Q_SLOTS: - void viewportCameraAreaGather() { // GIVEN @@ -1547,6 +1551,390 @@ private Q_SLOTS: QCOMPARE(mouseExited.count(), 0); } + void checkPickerAndLayerFilters() + { + // GIVEN + QmlSceneReader sceneReader(QUrl("qrc:/testscene_layerfilter.qml")); + QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root())); + QVERIFY(root); + + QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data())); + TestArbiter arbiter; + + // Runs Required jobs + runRequiredJobs(test.data()); + + // THEN + // object partially obscured by another viewport, make sure only visible portion is pickable + QList<Qt3DRender::QObjectPicker *> pickers = root->findChildren<Qt3DRender::QObjectPicker *>(); + QCOMPARE(pickers.size(), 2); + + Qt3DRender::QObjectPicker *picker1 = pickers.front(); + QCOMPARE(picker1->objectName(), QLatin1String("Picker1")); + + Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id()); + QVERIFY(backendPicker1); + + QSignalSpy mouseButtonPressedSpy1(picker1, &Qt3DRender::QObjectPicker::pressed); + + QVERIFY(mouseButtonPressedSpy1.isValid()); + + Qt3DRender::QObjectPicker *picker2 = pickers.last(); + QCOMPARE(picker2->objectName(), QLatin1String("Picker2")); + + Qt3DRender::Render::ObjectPicker *backendPicker2 = test->nodeManagers()->objectPickerManager()->lookupResource(picker2->id()); + QVERIFY(backendPicker2); + + QSignalSpy mouseButtonPressedSpy2(picker2, &Qt3DRender::QObjectPicker::pressed); + + QVERIFY(mouseButtonPressedSpy2.isValid()); + + // WHEN -> Pressed on object in vp1 + Qt3DRender::Render::PickBoundingVolumeJob pickBVJob; + initializePickBoundingVolumeJob(&pickBVJob, test.data()); + + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(150., 300.), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier) }); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(backendPicker1->isPressed()); + QVERIFY(picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 0); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(150., 300.), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(450., 300.), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Nothing happened + QVERIFY(!earlyReturn); + QVERIFY(backendPicker2->isPressed()); + QVERIFY(picker2->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + } + } + + void checkPickerAndNestedLayerFilters() + { + // GIVEN + QmlSceneReader sceneReader(QUrl("qrc:/testscene_nested_layerfilter.qml")); + QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root())); + QVERIFY(root); + + QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data())); + TestArbiter arbiter; + + // Runs Required jobs + runRequiredJobs(test.data()); + + // THEN + // object partially obscured by another viewport, make sure only visible portion is pickable + QList<Qt3DRender::QObjectPicker *> pickers = root->findChildren<Qt3DRender::QObjectPicker *>(); + QCOMPARE(pickers.size(), 5); + + Qt3DRender::QObjectPicker *picker1 = pickers[0]; + QCOMPARE(picker1->objectName(), QLatin1String("Picker1")); + Qt3DRender::QObjectPicker *picker2 = pickers[1]; + QCOMPARE(picker2->objectName(), QLatin1String("Picker2")); + Qt3DRender::QObjectPicker *picker3 = pickers[2]; + QCOMPARE(picker3->objectName(), QLatin1String("Picker3")); + Qt3DRender::QObjectPicker *picker4 = pickers[3]; + QCOMPARE(picker4->objectName(), QLatin1String("Picker4")); + Qt3DRender::QObjectPicker *picker5 = pickers[4]; + QCOMPARE(picker5->objectName(), QLatin1String("Picker5")); + + Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id()); + QVERIFY(backendPicker1); + + QSignalSpy mouseButtonPressedSpy1(picker1, &Qt3DRender::QObjectPicker::pressed); + QVERIFY(mouseButtonPressedSpy1.isValid()); + + Qt3DRender::Render::ObjectPicker *backendPicker2 = test->nodeManagers()->objectPickerManager()->lookupResource(picker2->id()); + QVERIFY(backendPicker2); + + QSignalSpy mouseButtonPressedSpy2(picker2, &Qt3DRender::QObjectPicker::pressed); + QVERIFY(mouseButtonPressedSpy2.isValid()); + + Qt3DRender::Render::ObjectPicker *backendPicker3 = test->nodeManagers()->objectPickerManager()->lookupResource(picker3->id()); + QVERIFY(backendPicker3); + + QSignalSpy mouseButtonPressedSpy3(picker3, &Qt3DRender::QObjectPicker::pressed); + QVERIFY(mouseButtonPressedSpy3.isValid()); + + Qt3DRender::Render::ObjectPicker *backendPicker4 = test->nodeManagers()->objectPickerManager()->lookupResource(picker4->id()); + QVERIFY(backendPicker4); + + QSignalSpy mouseButtonPressedSpy4(picker4, &Qt3DRender::QObjectPicker::pressed); + QVERIFY(mouseButtonPressedSpy4.isValid()); + + Qt3DRender::Render::ObjectPicker *backendPicker5 = test->nodeManagers()->objectPickerManager()->lookupResource(picker5->id()); + QVERIFY(backendPicker5); + + QSignalSpy mouseButtonPressedSpy5(picker5, &Qt3DRender::QObjectPicker::pressed); + QVERIFY(mouseButtonPressedSpy5.isValid()); + + Qt3DRender::Render::PickBoundingVolumeJob pickBVJob; + initializePickBoundingVolumeJob(&pickBVJob, test.data()); + + // Picker1 -> Viewport 1 + // Picker2 -> Viewport 2 + // Picker3 -> No Viewport + // Picker4 -> Viewport 1 and 2 + // Picker5 -> Viewport 1 + + // WHEN -> Pressed on object1 in VP1 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(200.0f, 300.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(backendPicker1->isPressed()); + QVERIFY(picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(!backendPicker4->isPressed()); + QVERIFY(!picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 0); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 0); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(200.0f, 300.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + + // WHEN -> Pressed on object2 in VP2 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(541.0f, 183.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(backendPicker2->isPressed()); + QVERIFY(picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(!backendPicker4->isPressed()); + QVERIFY(!picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 0); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(541.0f, 183.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + + // WHEN -> Pressed on object3 in VP1 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(80.0f, 150.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Nothing Pressed as not selected by Layer + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(!backendPicker4->isPressed()); + QVERIFY(!picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 0); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + } + + // WHEN -> Pressed on object3 in VP2 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(504.0f, 263.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Nothing Pressed as not selected by Layer + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(!backendPicker4->isPressed()); + QVERIFY(!picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 0); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + } + + // WHEN -> Pressed on object4 in VP1 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(160.0f, 431.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(backendPicker4->isPressed()); + QVERIFY(picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 1); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(160.0f, 431.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + + // WHEN -> Pressed on object4 in VP2 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(447.0f, 472.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(backendPicker4->isPressed()); + QVERIFY(picker4->isPressed()); + QVERIFY(!backendPicker5->isPressed()); + QVERIFY(!picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 2); + QCOMPARE(mouseButtonPressedSpy5.count(), 0); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(447.0f, 472.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + + // WHEN -> Pressed on object5 in VP1 + { + QList<QPair<QObject *, QMouseEvent>> events; + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(153.0f, 195.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + bool earlyReturn = !pickBVJob.runHelper(); + Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager()); + + // THEN -> Pressed + QVERIFY(!earlyReturn); + QVERIFY(!backendPicker1->isPressed()); + QVERIFY(!picker1->isPressed()); + QVERIFY(!backendPicker2->isPressed()); + QVERIFY(!picker2->isPressed()); + QVERIFY(!backendPicker3->isPressed()); + QVERIFY(!picker3->isPressed()); + QVERIFY(!backendPicker4->isPressed()); + QVERIFY(!picker4->isPressed()); + QVERIFY(backendPicker5->isPressed()); + QVERIFY(picker5->isPressed()); + QCOMPARE(mouseButtonPressedSpy1.count(), 1); + QCOMPARE(mouseButtonPressedSpy2.count(), 1); + QCOMPARE(mouseButtonPressedSpy3.count(), 0); + QCOMPARE(mouseButtonPressedSpy4.count(), 2); + QCOMPARE(mouseButtonPressedSpy5.count(), 1); + + events.clear(); + + events.push_back({nullptr, QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(153.0f, 195.0f), + Qt::LeftButton, Qt::LeftButton, Qt::NoModifier)}); + pickBVJob.setMouseEvents(events); + pickBVJob.runHelper(); + } + } + void checkMultipleRayDirections_data() { QTest::addColumn<QVector3D>("cameraOrigin"); @@ -1879,7 +2267,6 @@ private Q_SLOTS: QCOMPARE(vca.cameraId, camera->id()); QCOMPARE(vca.viewport, QRectF(0., 0., 1., 1.)); } - }; QTEST_MAIN(tst_PickBoundingVolumeJob) diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp index 9eb73cbd6..6638d88d9 100644 --- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp +++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp @@ -58,6 +58,7 @@ #include <Qt3DRender/private/calcboundingvolumejob_p.h> #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h> #include <Qt3DRender/private/loadbufferjob_p.h> +#include <Qt3DRender/private/updateentitylayersjob_p.h> #include <Qt3DRender/private/buffermanager_p.h> #include <Qt3DRender/private/geometryrenderermanager_p.h> @@ -212,6 +213,10 @@ void runRequiredJobs(Qt3DRender::TestAspect *test) Qt3DRender::Render::CalcGeometryTriangleVolumes calcGeometryTriangles(geometryRendererId, test->nodeManagers()); calcGeometryTriangles.run(); } + + Qt3DRender::Render::UpdateEntityLayersJob updateEntityLayer; + updateEntityLayer.setManager(test->nodeManagers()); + updateEntityLayer.run(); } void initializeJob(Qt3DRender::Render::RayCastingJob *job, Qt3DRender::TestAspect *test) diff --git a/tests/auto/render/shadergraph/qshadernodes/tst_qshadernodes.cpp b/tests/auto/render/shadergraph/qshadernodes/tst_qshadernodes.cpp index 2cd2ff90d..2c53de349 100644 --- a/tests/auto/render/shadergraph/qshadernodes/tst_qshadernodes.cpp +++ b/tests/auto/render/shadergraph/qshadernodes/tst_qshadernodes.cpp @@ -540,8 +540,8 @@ void tst_QShaderNodes::shouldHandleNodeRulesSupportAndOrder() QCOMPARE(node.availableFormats().at(2), openGL3); QCOMPARE(node.rule(openGLES2), es2Rule); QCOMPARE(node.rule(openGL3), gl3bisRule); - QCOMPARE(node.rule(openGL32), gl3bisRule); - QCOMPARE(node.rule(openGL4), gl3bisRule); + QCOMPARE(node.rule(openGL32), gl32Rule); + QCOMPARE(node.rule(openGL4), gl32Rule); } QTEST_MAIN(tst_QShaderNodes) |