Revision control
Copy as Markdown
// Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "pickboundingvolumeutils_p.h"
#include <Qt3DRender/private/geometryrenderer_p.h>
#include <Qt3DRender/private/framegraphnode_p.h>
#include <Qt3DRender/private/cameralens_p.h>
#include <Qt3DRender/private/cameraselectornode_p.h>
#include <Qt3DRender/private/viewportnode_p.h>
#include <Qt3DRender/private/rendersurfaceselector_p.h>
#include <Qt3DRender/private/triangleboundingvolume_p.h>
#include <Qt3DRender/private/nodemanagers_p.h>
#include <Qt3DRender/private/sphere_p.h>
#include <Qt3DRender/private/entity_p.h>
#include <Qt3DRender/private/trianglesvisitor_p.h>
#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>
#include <functional>
QT_BEGIN_NAMESPACE
namespace Qt3DRender {
using namespace Qt3DRender::RayCasting;
namespace Render {
namespace PickingUtils {
PickConfiguration::PickConfiguration(FrameGraphNode *frameGraphRoot, RenderSettings *renderSettings)
{
ViewportCameraAreaGatherer vcaGatherer;
// TO DO: We could cache this and only gather when we know the FrameGraph tree has changed
vcaDetails = vcaGatherer.gather(frameGraphRoot);
// If we have no viewport / camera or area, return early
if (vcaDetails.empty())
return;
// 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
trianglePickingRequested = (renderSettings->pickMethod() & QPickingSettings::TrianglePicking);
edgePickingRequested = (renderSettings->pickMethod() & QPickingSettings::LinePicking);
pointPickingRequested = (renderSettings->pickMethod() & QPickingSettings::PointPicking);
primitivePickingRequested = pointPickingRequested | edgePickingRequested | trianglePickingRequested;
frontFaceRequested = renderSettings->faceOrientationPickingMode() != QPickingSettings::BackFace;
backFaceRequested = renderSettings->faceOrientationPickingMode() != QPickingSettings::FrontFace;
pickWorldSpaceTolerance = renderSettings->pickWorldSpaceTolerance();
}
void ViewportCameraAreaGatherer::visit(FrameGraphNode *node)
{
const auto children = node->children();
for (Render::FrameGraphNode *n : children)
visit(n);
if (node->childrenIds().empty())
m_leaves.push_back(node);
}
ViewportCameraAreaDetails ViewportCameraAreaGatherer::gatherUpViewportCameraAreas(Render::FrameGraphNode *node) const
{
ViewportCameraAreaDetails vca;
vca.viewport = QRectF(0., 0., 1., 1.);
while (node) {
if (node->isEnabled()) {
switch (node->nodeType()) {
case FrameGraphNode::CameraSelector:
vca.cameraId = static_cast<const CameraSelector *>(node)->cameraUuid();
break;
case FrameGraphNode::Viewport: {
auto vnode = static_cast<const ViewportNode *>(node);
// we want the leaf viewport so if we have a viewport node already don't override it with its parent
if (!vca.viewportNodeId)
vca.viewportNodeId = vnode->peerId();
vca.viewport = ViewportNode::computeViewport(vca.viewport, vnode);
break;
}
case FrameGraphNode::Surface: {
auto selector = static_cast<const RenderSurfaceSelector *>(node);
vca.area = selector->renderTargetSize();
vca.surface = selector->surface();
break;
}
case FrameGraphNode::NoPicking: {
// Return an empty/invalid ViewportCameraAreaDetails which will
// 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;
}
}
node = node->parent();
}
return vca;
}
std::vector<ViewportCameraAreaDetails> ViewportCameraAreaGatherer::gather(FrameGraphNode *root)
{
// Retrieve all leaves
visit(root);
std::vector<ViewportCameraAreaDetails> vcaTriplets;
vcaTriplets.reserve(m_leaves.size());
// Find all viewport/camera pairs by traversing from leaf to root
for (Render::FrameGraphNode *leaf : m_leaves) {
ViewportCameraAreaDetails vcaDetails = gatherUpViewportCameraAreas(leaf);
if (!m_targetCamera.isNull() && vcaDetails.cameraId != m_targetCamera)
continue;
if (!vcaDetails.cameraId.isNull() && isUnique(vcaTriplets, vcaDetails))
vcaTriplets.push_back(vcaDetails);
}
return vcaTriplets;
}
bool ViewportCameraAreaGatherer::isUnique(const std::vector<ViewportCameraAreaDetails> &vcaList,
const ViewportCameraAreaDetails &vca) const
{
for (const ViewportCameraAreaDetails &listItem : vcaList) {
if (vca.cameraId == listItem.cameraId &&
vca.viewport == listItem.viewport &&
vca.surface == listItem.surface &&
vca.area == listItem.area &&
vca.layersFilters == listItem.layersFilters)
return false;
}
return true;
}
class TriangleCollisionVisitor : public TrianglesVisitor
{
public:
HitList hits;
TriangleCollisionVisitor(NodeManagers* manager, const Entity *root, const RayCasting::QRay3D& ray,
bool frontFaceRequested, bool backFaceRequested)
: TrianglesVisitor(manager), m_root(root), m_ray(ray), m_triangleIndex(0)
, m_frontFaceRequested(frontFaceRequested), m_backFaceRequested(backFaceRequested)
{
m_worldMatrix = *m_root->worldTransform();
m_localRay = m_ray;
m_localRay.transform(m_worldMatrix.inverted());
}
private:
const Entity *m_root;
RayCasting::QRay3D m_ray;
RayCasting::QRay3D m_localRay;
Matrix4x4 m_worldMatrix;
uint m_triangleIndex;
bool m_frontFaceRequested;
bool m_backFaceRequested;
void visit(uint andx, const Vector3D &a,
uint bndx, const Vector3D &b,
uint cndx, const Vector3D &c) override;
bool intersectsSegmentTriangle(uint andx, const Vector3D &a,
uint bndx, const Vector3D &b,
uint cndx, const Vector3D &c);
};
void TriangleCollisionVisitor::visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
{
bool intersected = m_frontFaceRequested && intersectsSegmentTriangle(cndx, c, bndx, b, andx, a); // front facing
if (!intersected && m_backFaceRequested) {
intersected = intersectsSegmentTriangle(andx, a, bndx, b, cndx, c); // back facing
}
m_triangleIndex++;
}
bool TriangleCollisionVisitor::intersectsSegmentTriangle(uint andx, const Vector3D &a, uint bndx, const Vector3D &b, uint cndx, const Vector3D &c)
{
float t = 0.0f;
Vector3D uvw;
bool intersected = Render::intersectsSegmentTriangle(m_localRay, a, b, c, uvw, t);
if (intersected) {
QCollisionQueryResult::Hit queryResult;
queryResult.m_type = QCollisionQueryResult::Hit::Triangle;
queryResult.m_entityId = m_root->peerId();
queryResult.m_primitiveIndex = m_triangleIndex;
queryResult.m_vertexIndex[0] = andx;
queryResult.m_vertexIndex[1] = bndx;
queryResult.m_vertexIndex[2] = cndx;
queryResult.m_uvw = uvw;
queryResult.m_intersection = m_worldMatrix.map(m_localRay.point(t * m_localRay.distance()));
queryResult.m_distance = m_ray.projectedDistance(queryResult.m_intersection);
hits.push_back(queryResult);
}
return intersected;
}
class LineCollisionVisitor : public SegmentsVisitor
{
public:
HitList hits;
LineCollisionVisitor(NodeManagers* manager, const Entity *root, const RayCasting::QRay3D& ray,
float pickWorldSpaceTolerance)
: SegmentsVisitor(manager), m_root(root), m_ray(ray)
, m_segmentIndex(0), m_pickWorldSpaceTolerance(pickWorldSpaceTolerance)
{
}
private:
const Entity *m_root;
RayCasting::QRay3D m_ray;
uint m_segmentIndex;
float m_pickWorldSpaceTolerance;
void visit(uint andx, const Vector3D &a,
uint bndx, const Vector3D &b) override;
bool intersectsSegmentSegment(uint andx, const Vector3D &a,
uint bndx, const Vector3D &b);
bool rayToLineSegment(const Vector3D& lineStart,const Vector3D& lineEnd,
float &distance, Vector3D &intersection) const;
};
void LineCollisionVisitor::visit(uint andx, const Vector3D &a, uint bndx, const Vector3D &b)
{
const Matrix4x4 &mat = *m_root->worldTransform();
const Vector3D tA = mat.map(a);
const Vector3D tB = mat.map(b);
intersectsSegmentSegment(andx, tA, bndx, tB);
m_segmentIndex++;
}
bool LineCollisionVisitor::intersectsSegmentSegment(uint andx, const Vector3D &a,
uint bndx, const Vector3D &b)
{
float distance = 0.f;
Vector3D intersection;
bool res = rayToLineSegment(a, b, distance, intersection);
if (res) {
QCollisionQueryResult::Hit queryResult;
queryResult.m_type = QCollisionQueryResult::Hit::Edge;
queryResult.m_entityId = m_root->peerId();
queryResult.m_primitiveIndex = m_segmentIndex;
queryResult.m_vertexIndex[0] = andx;
queryResult.m_vertexIndex[1] = bndx;
queryResult.m_intersection = intersection;
queryResult.m_distance = m_ray.projectedDistance(queryResult.m_intersection);
hits.push_back(queryResult);
return true;
}
return false;
}
bool LineCollisionVisitor::rayToLineSegment(const Vector3D& lineStart,const Vector3D& lineEnd,
float &distance, Vector3D &intersection) const
{
const float epsilon = 0.00000001f;
const Vector3D u = m_ray.direction() * m_ray.distance();
const Vector3D v = lineEnd - lineStart;
const Vector3D w = m_ray.origin() - lineStart;
const float a = Vector3D::dotProduct(u, u);
const float b = Vector3D::dotProduct(u, v);
const float c = Vector3D::dotProduct(v, v);
const float d = Vector3D::dotProduct(u, w);
const float e = Vector3D::dotProduct(v, w);
const float D = a * c - b * b;
float sc, sN, sD = D;
float tc, tN, tD = D;
if (D < epsilon) {
sN = 0.0;
sD = 1.0;
tN = e;
tD = c;
} else {
sN = (b * e - c * d);
tN = (a * e - b * d);
if (sN < 0.0) {
sN = 0.0;
tN = e;
tD = c;
}
}
if (tN < 0.0) {
tN = 0.0;
if (-d < 0.0)
sN = 0.0;
else {
sN = -d;
sD = a;
}
} else if (tN > tD) {
tN = tD;
if ((-d + b) < 0.0)
sN = 0;
else {
sN = (-d + b);
sD = a;
}
}
sc = (qAbs(sN) < epsilon ? 0.0f : sN / sD);
tc = (qAbs(tN) < epsilon ? 0.0f : tN / tD);
const Vector3D dP = w + (sc * u) - (tc * v);
const float f = dP.length();
if (f < m_pickWorldSpaceTolerance) {
distance = sc * u.length();
intersection = lineStart + v * tc;
return true;
}
return false;
}
class PointCollisionVisitor : public PointsVisitor
{
public:
HitList hits;
PointCollisionVisitor(NodeManagers* manager, const Entity *root, const RayCasting::QRay3D& ray,
float pickWorldSpaceTolerance)
: PointsVisitor(manager), m_root(root), m_ray(ray)
, m_pointIndex(0), m_pickWorldSpaceTolerance(pickWorldSpaceTolerance)
{
}
private:
const Entity *m_root;
RayCasting::QRay3D m_ray;
uint m_pointIndex;
float m_pickWorldSpaceTolerance;
void visit(uint ndx, const Vector3D &p) override;
double pointToRayDistance(const Vector3D &a, Vector3D &p)
{
const Vector3D v = a - m_ray.origin();
const double t = Vector3D::dotProduct(v, m_ray.direction());
p = m_ray.origin() + t * m_ray.direction();
return (p - a).length();
}
};
void PointCollisionVisitor::visit(uint ndx, const Vector3D &p)
{
const Matrix4x4 &mat = *m_root->worldTransform();
const Vector3D tP = mat.map(p);
Vector3D intersection;
float d = pointToRayDistance(tP, intersection);
if (d < m_pickWorldSpaceTolerance) {
QCollisionQueryResult::Hit queryResult;
queryResult.m_type = QCollisionQueryResult::Hit::Point;
queryResult.m_entityId = m_root->peerId();
queryResult.m_primitiveIndex = m_pointIndex;
queryResult.m_vertexIndex[0] = ndx;
queryResult.m_intersection = intersection;
queryResult.m_distance = d;
hits.push_back(queryResult);
}
m_pointIndex++;
}
HitList reduceToFirstHit(HitList &result, const HitList &intermediate)
{
if (!intermediate.empty()) {
if (result.empty())
result.push_back(intermediate.front());
float closest = result.front().m_distance;
for (const auto &v : intermediate) {
if (v.m_distance < closest) {
result.insert(result.begin(), v);
closest = v.m_distance;
}
}
while (result.size() > 1)
result.pop_back();
}
return result;
}
struct HighestPriorityHitReducer
{
// No need to protect this from concurrent access as the table
// is read only
const QHash<Qt3DCore::QNodeId, int> entityToPriorityTable;
HitList operator()(HitList &result, const HitList &intermediate)
{
// Sort by priority first
// If we have equal priorities, we then sort by distance
if (!intermediate.empty()) {
if (result.empty())
result.push_back(intermediate.front());
int currentPriority = entityToPriorityTable.value(result.front().m_entityId, 0);
float closest = result.front().m_distance;
for (const auto &v : intermediate) {
const int newEntryPriority = entityToPriorityTable.value(v.m_entityId, 0);
if (newEntryPriority > currentPriority) {
result.insert(result.begin(), v);
currentPriority = newEntryPriority;
closest = v.m_distance;
} else if (newEntryPriority == currentPriority) {
if (v.m_distance < closest) {
result.insert(result.begin(), v);
closest = v.m_distance;
currentPriority = newEntryPriority;
}
}
}
while (result.size() > 1)
result.pop_back();
}
return result;
}
};
HitList reduceToAllHits(HitList &results, const HitList &intermediate)
{
if (!intermediate.empty())
results.insert(results.end(), intermediate.begin(), intermediate.end());
return results;
}
AbstractCollisionGathererFunctor::AbstractCollisionGathererFunctor()
: m_manager(nullptr)
{ }
AbstractCollisionGathererFunctor::~AbstractCollisionGathererFunctor()
{ }
HitList AbstractCollisionGathererFunctor::operator ()(const Entity *entity) const
{
if (m_objectPickersRequired) {
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 ...
auto parentEntity = entity;
while (objectPickerHandle.isNull() && parentEntity != nullptr) {
parentEntity = parentEntity->parent();
if (parentEntity != nullptr)
objectPickerHandle = parentEntity->componentHandle<ObjectPicker>();
}
ObjectPicker *objectPicker = m_manager->objectPickerManager()->data(objectPickerHandle);
if (objectPicker == nullptr || !objectPicker->isEnabled())
return {}; // don't bother picking entities that don't
// have an object picker, or if it's disabled
}
return pick(entity);
}
bool AbstractCollisionGathererFunctor::rayHitsEntity(const Entity *entity) const
{
QRayCastingService rayCasting;
const QCollisionQueryResult::Hit queryResult = rayCasting.query(m_ray, entity->worldBoundingVolume());
return queryResult.m_distance >= 0.f;
}
void AbstractCollisionGathererFunctor::sortHits(HitList &results)
{
auto compareHitsDistance = [](const HitList::value_type &a,
const HitList::value_type &b) {
return a.m_distance < b.m_distance;
};
std::sort(results.begin(), results.end(), compareHitsDistance);
}
namespace {
// Workaround to avoid passing *this into the blockMappedReduce calls for the
// mapFunctor which would cause an SSE alignment error on Windows Also note
// that a lambda doesn't work since we need the typedef result_type defined to
// work with QtConcurrent
struct MapFunctorHolder
{
MapFunctorHolder(const AbstractCollisionGathererFunctor *gatherer)
: m_gatherer(gatherer)
{}
// This define is required to work with QtConcurrent
typedef HitList result_type;
HitList operator ()(const Entity *e) const { return m_gatherer->operator ()(e); }
const AbstractCollisionGathererFunctor *m_gatherer;
};
} // anonymous
HitList EntityCollisionGathererFunctor::computeHits(const std::vector<Entity *> &entities,
Qt3DRender::QPickingSettings::PickResultMode mode)
{
std::function<HitList (HitList &, const HitList &)> reducerOp;
switch (mode) {
case QPickingSettings::AllPicks:
reducerOp = PickingUtils::reduceToAllHits;
break;
case QPickingSettings::NearestPriorityPick:
reducerOp = HighestPriorityHitReducer{ m_entityToPriorityTable };
break;
case QPickingSettings::NearestPick:
reducerOp = PickingUtils::reduceToFirstHit;
break;
}
const MapFunctorHolder holder(this);
#if QT_CONFIG(concurrent)
return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
#else
HitList sphereHits;
QList<PickingUtils::EntityCollisionGathererFunctor::result_type> results;
for (const Entity *entity : entities)
sphereHits = reducerOp(sphereHits, holder(entity));
return sphereHits;
#endif
}
HitList EntityCollisionGathererFunctor::pick(const Entity *entity) const
{
HitList result;
QRayCastingService rayCasting;
const QCollisionQueryResult::Hit queryResult = rayCasting.query(m_ray, entity->worldBoundingVolume());
if (queryResult.m_distance >= 0.f)
result.push_back(queryResult);
return result;
}
HitList TriangleCollisionGathererFunctor::computeHits(const std::vector<Entity *> &entities,
Qt3DRender::QPickingSettings::PickResultMode mode)
{
std::function<HitList (HitList &, const HitList &)> reducerOp;
switch (mode) {
case QPickingSettings::AllPicks:
reducerOp = PickingUtils::reduceToAllHits;
break;
case QPickingSettings::NearestPriorityPick:
reducerOp = HighestPriorityHitReducer { m_entityToPriorityTable };
break;
case QPickingSettings::NearestPick:
reducerOp = PickingUtils::reduceToFirstHit;
break;
}
const MapFunctorHolder holder(this);
#if QT_CONFIG(concurrent)
return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
#else
HitList sphereHits;
QList<PickingUtils::TriangleCollisionGathererFunctor::result_type> results;
for (const Entity *entity : entities)
sphereHits = reducerOp(sphereHits, holder(entity));
return sphereHits;
#endif
}
HitList TriangleCollisionGathererFunctor::pick(const Entity *entity) const
{
HitList result;
PickingProxy *proxy = entity->renderComponent<PickingProxy>();
if (proxy && proxy->isEnabled() && proxy->isValid()) {
if (rayHitsEntity(entity)) {
TriangleCollisionVisitor visitor(m_manager, entity, m_ray, m_frontFaceRequested, m_backFaceRequested);
visitor.apply(proxy, entity->peerId());
result = visitor.hits;
sortHits(result);
}
} else {
GeometryRenderer *gRenderer = entity->renderComponent<GeometryRenderer>();
if (!gRenderer || !gRenderer->isEnabled())
return result;
if (rayHitsEntity(entity)) {
TriangleCollisionVisitor visitor(m_manager, entity, m_ray, m_frontFaceRequested, m_backFaceRequested);
visitor.apply(gRenderer, entity->peerId());
result = visitor.hits;
sortHits(result);
}
}
return result;
}
HitList LineCollisionGathererFunctor::computeHits(const std::vector<Entity *> &entities,
Qt3DRender::QPickingSettings::PickResultMode mode)
{
std::function<HitList (HitList &, const HitList &)> reducerOp;
switch (mode) {
case QPickingSettings::AllPicks:
reducerOp = PickingUtils::reduceToAllHits;
break;
case QPickingSettings::NearestPriorityPick:
reducerOp = HighestPriorityHitReducer { m_entityToPriorityTable };
break;
case QPickingSettings::NearestPick:
reducerOp = PickingUtils::reduceToFirstHit;
break;
}
const MapFunctorHolder holder(this);
#if QT_CONFIG(concurrent)
return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
#else
HitList sphereHits;
QList<PickingUtils::LineCollisionGathererFunctor::result_type> results;
for (const Entity *entity : entities)
sphereHits = reducerOp(sphereHits, holder(entity));
return sphereHits;
#endif
}
HitList LineCollisionGathererFunctor::pick(const Entity *entity) const
{
HitList result;
PickingProxy *proxy = entity->renderComponent<PickingProxy>();
if (proxy && proxy->isEnabled() && proxy->isValid()) {
if (rayHitsEntity(entity)) {
LineCollisionVisitor visitor(m_manager, entity, m_ray, m_pickWorldSpaceTolerance);
visitor.apply(proxy, entity->peerId());
result = visitor.hits;
sortHits(result);
}
} else {
GeometryRenderer *gRenderer = entity->renderComponent<GeometryRenderer>();
if (!gRenderer)
return result;
if (rayHitsEntity(entity)) {
LineCollisionVisitor visitor(m_manager, entity, m_ray, m_pickWorldSpaceTolerance);
visitor.apply(gRenderer, entity->peerId());
result = visitor.hits;
sortHits(result);
}
}
return result;
}
HitList PointCollisionGathererFunctor::computeHits(const std::vector<Entity *> &entities,
Qt3DRender::QPickingSettings::PickResultMode mode)
{
std::function<HitList (HitList &, const HitList &)> reducerOp;
switch (mode) {
case QPickingSettings::AllPicks:
reducerOp = PickingUtils::reduceToAllHits;
break;
case QPickingSettings::NearestPriorityPick:
reducerOp = HighestPriorityHitReducer { m_entityToPriorityTable };
break;
case QPickingSettings::NearestPick:
reducerOp = PickingUtils::reduceToFirstHit;
break;
}
const MapFunctorHolder holder(this);
#if QT_CONFIG(concurrent)
return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
#else
HitList sphereHits;
QList<PickingUtils::PointCollisionGathererFunctor::result_type> results;
for (const Entity *entity : entities)
sphereHits = reducerOp(sphereHits, holder(entity));
return sphereHits;
#endif
}
HitList PointCollisionGathererFunctor::pick(const Entity *entity) const
{
HitList result;
PickingProxy *proxy = entity->renderComponent<PickingProxy>();
if (proxy && proxy->isEnabled() && proxy->isValid() && proxy->primitiveType() != Qt3DCore::QGeometryView::Points) {
if (rayHitsEntity(entity)) {
PointCollisionVisitor visitor(m_manager, entity, m_ray, m_pickWorldSpaceTolerance);
visitor.apply(proxy, entity->peerId());
result = visitor.hits;
sortHits(result);
}
} else {
GeometryRenderer *gRenderer = entity->renderComponent<GeometryRenderer>();
if (!gRenderer)
return result;
if (gRenderer->primitiveType() != Qt3DRender::QGeometryRenderer::Points)
return result;
if (rayHitsEntity(entity)) {
PointCollisionVisitor visitor(m_manager, entity, m_ray, m_pickWorldSpaceTolerance);
visitor.apply(gRenderer, entity->peerId());
result = visitor.hits;
sortHits(result);
}
}
return result;
}
HierarchicalEntityPicker::HierarchicalEntityPicker(const QRay3D &ray, bool requireObjectPicker)
: m_ray(ray)
, m_objectPickersRequired(requireObjectPicker)
{
}
void HierarchicalEntityPicker::setLayerFilterIds(const Qt3DCore::QNodeIdVector &layerFilterIds)
{
m_layerFilterIds = layerFilterIds;
}
void HierarchicalEntityPicker::setLayerIds(const Qt3DCore::QNodeIdVector &layerIds,
QAbstractRayCaster::FilterMode mode)
{
m_layerIds = layerIds;
m_layerFilterMode = mode;
}
bool HierarchicalEntityPicker::collectHits(NodeManagers *manager, Entity *root)
{
m_hits.clear();
m_entities.clear();
m_entityToPriorityTable.clear();
QRayCastingService rayCasting;
struct EntityData {
Entity* entity;
bool hasObjectPicker;
int priority;
};
std::vector<EntityData> worklist;
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.empty();
const bool hasLayers = !m_layerIds.empty();
const bool hasLayerFiltering = hasLayerFilters || hasLayers;
std::vector<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.empty()) {
layerFilterJob.setLayerFilters(m_layerFilterIds);
layerFilterJob.run();
layerFilterEntities = layerFilterJob.filteredEntities();
}
}
while (!worklist.empty()) {
EntityData current = worklist.back();
worklist.pop_back();
// first pick entry sub-scene-graph
QCollisionQueryResult::Hit queryResult =
rayCasting.query(m_ray, current.entity->worldBoundingVolumeWithChildren());
if (queryResult.m_distance < 0.f)
continue;
// if we get a hit, we check again for this specific entity
queryResult = rayCasting.query(m_ray, current.entity->worldBoundingVolume());
// 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 || Qt3DCore::contains(layerFilterEntities, 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);
}
// and pick children
const auto &childrenHandles = current.entity->childrenHandles();
for (const HEntity &handle : childrenHandles) {
Entity *child = manager->renderNodesManager()->data(handle);
if (child) {
ObjectPicker *childPicker = child->renderComponent<ObjectPicker>();
worklist.push_back({child, current.hasObjectPicker || childPicker,
(childPicker ? childPicker->priority() : current.priority)});
}
}
}
return !m_hits.empty();
}
} // PickingUtils
} // Render
} // Qt3DRender
QT_END_NAMESPACE