qt/qtquick3d/tests/auto/quick3d_visual/picking/tst_picking.cpp

Revision control

Copy as Markdown

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QTest>
#include <QtQuick/QQuickItem>
#include <QtQuick3D/private/qquick3dviewport_p.h>
#include <QtQuick3D/private/qquick3dmodel_p.h>
#include <QtQuick3D/private/qquick3dpickresult_p.h>
#include <QtQuick3D/private/qquick3ditem2d_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderray_p.h>
#include "../shared/util.h"
Q_DECLARE_METATYPE(QSSGCullFaceMode)
class CustomGeometry : public QQuick3DGeometry
{
Q_OBJECT
Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)
QML_NAMED_ELEMENT(CustomGeometry)
public:
CustomGeometry(uint count);
int count() { return m_count; }
void setCount(int count);
signals:
void countChanged();
private:
struct Vertex {
QVector3D position;
QVector3D normal;
QVector2D uv;
};
void updateData();
uint m_count = 500;
};
CustomGeometry::CustomGeometry(uint count)
{
m_count = count;
updateData();
}
void CustomGeometry::setCount(int count)
{
m_count = count;
updateData();
emit countChanged();
}
void CustomGeometry::updateData()
{
QVector<Vertex> vertices;
QVector<QPoint> coords;
int rowCount = m_count;
int columnCount = m_count;
float uvX = 1.0f / float(rowCount - 1);
float uvY = 1.0f / float(columnCount - 1);
for (int i = 0; i < columnCount; i++) {
for (int j = 0; j < rowCount; j++) {
Vertex v;
float x = 4.0f / (columnCount-1) * i - 2.0f;
float z = 4.0f / (rowCount-1) * j - 2.0f;
v.position = QVector3D(x, .0f, z);
v.normal = QVector3D(.0f, .0f, .0f);
v.uv = QVector2D(j * uvX, i * uvY);
vertices.push_back(v);
coords.push_back(QPoint(i, j));
}
}
QVector3D boundsMin = QVector3D(-2.0f, -1.0f, -2.0f);
QVector3D boundsMax = QVector3D(2.0f, 1.0f, 2.0f);
setBounds(boundsMin, boundsMax);
QVector<quint32> indices;
for (int i = 0; i < columnCount - 1; i++) {
for (int j = 0; j < rowCount -1; j++) {
indices.push_back(i * rowCount + j);
indices.push_back(i * rowCount + j + 1);
indices.push_back(i * rowCount + j + rowCount);
indices.push_back(i * rowCount + j + 1);
indices.push_back(i * rowCount + j + 1 + rowCount);
indices.push_back(i * rowCount + j + rowCount);
}
}
setStride(sizeof(Vertex));
setPrimitiveType(QQuick3DGeometry::PrimitiveType::Triangles);
addAttribute(QQuick3DGeometry::Attribute::PositionSemantic,
0,
QQuick3DGeometry::Attribute::F32Type);
addAttribute(QQuick3DGeometry::Attribute::TexCoord0Semantic,
sizeof(QVector3D) * 2,
QQuick3DGeometry::Attribute::F32Type);
addAttribute(QQuick3DGeometry::Attribute::NormalSemantic,
sizeof(QVector3D),
QQuick3DGeometry::Attribute::F32Type);
addAttribute(QQuick3DGeometry::Attribute::IndexSemantic,
0,
QQuick3DGeometry::Attribute::U32Type);
QByteArray vertexBuffer(reinterpret_cast<char *>(vertices.data()), vertices.size() * sizeof(Vertex));
setVertexData(vertexBuffer);
QByteArray indexBuffer(reinterpret_cast<char *>(indices.data()), indices.size() * sizeof(quint32));
setIndexData(indexBuffer);
update();
}
class tst_Picking : public QQuick3DDataTest
{
Q_OBJECT
private Q_SLOTS:
void initTestCase() override;
void test_view_picking();
void test_ray_picking();
void test_object_picking2();
void test_item_picking();
void test_picking_QTBUG_111997();
void test_picking_corner_case();
void test_triangleIntersect();
void test_sphere_geometry();
void test_closest_point_picking();
void test_triangleIntersect_cullMode_data();
void test_triangleIntersect_cullMode();
void test_picking_cull_mode();
private:
QQuickItem *find2DChildIn3DNode(QQuickView *view, const QString &objectName, const QString &itemName);
};
void tst_Picking::initTestCase()
{
QQuick3DDataTest::initTestCase();
if (!initialized())
return;
}
QQuickItem *tst_Picking::find2DChildIn3DNode(QQuickView *view, const QString &objectName, const QString &itemName)
{
QQuick3DNode *obj = view->rootObject()->findChild<QQuick3DNode*>(objectName);
if (!obj)
return nullptr;
QQuickItem *subsceneRoot = obj->findChild<QQuickItem *>();
if (!subsceneRoot)
subsceneRoot = obj->findChild<QQuick3DItem2D *>()->contentItem();
if (!subsceneRoot)
return nullptr;
QObject *child = subsceneRoot->findChild<QObject *>(itemName);
return static_cast<QQuickItem *>(child);
}
void tst_Picking::test_view_picking()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("picking.qml"), QSize(400, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
QQuick3DModel *model2 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model2"));
QVERIFY(model2);
QQuick3DModel *instancedModel = view3d->findChild<QQuick3DModel *>(QStringLiteral("instancedModel"));
QVERIFY(instancedModel);
QQuickItem *item2d = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dNode", "item2d"));
QVERIFY(item2d);
const qreal dpr = view->devicePixelRatio();
if (dpr != 1.0) {
QSKIP("Test uses window positions to get exact values and those assume DPR of 1.0");
}
// Pick nearest based on viewport position
// Center of model1
auto result = view3d->pick(200, 200);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.distance(), 550.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.5f, 0.5f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Upper right corner of model1
result = view3d->pick(250, 150);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.distance(), 550.0f);
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 1.0f));
QCOMPARE(result.scenePosition(), QVector3D(50.0f, 50.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(50.0f, 50.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Just outside model1's upper right corner, so should hit the model behind (model2)
// This one might cause some floating point grief
result = view3d->pick(251, 151);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.distance(), 600.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.5099999904632568, 0.4899999797344208));
QCOMPARE(result.scenePosition(), QVector3D(51.0f, 49.0f, -0.000003814697265625));
QCOMPARE(result.position(), QVector3D(1.0f, -1.0f, 49.999996185302734f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Upper right corner of model2
result = view3d->pick(300, 100);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.distance(), 600.0f);
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 1.0f));
QCOMPARE(result.scenePosition(), QVector3D(100.0f, 100.0f, 0.0f));
QCOMPARE(result.position(), QVector3D(50.0f, 50.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Just outside model2's upper right corner, so there should be no hit
result = view3d->pick(301, 99);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QCOMPARE(result.objectHit(), nullptr);
QCOMPARE(result.itemHit(), nullptr);
// Center of the third entry in the instance table
result = view3d->pick(350, 200);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), instancedModel);
QCOMPARE(result.distance(), 550.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.0f, 0.5f));
QCOMPARE(result.scenePosition(), QVector3D(150.0f, 0.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(-50.0f, 0.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 2);
QCOMPARE(result.itemHit(), nullptr);
// The bottom right of instancedModel,
// overlapped by model1 and then model2, should hit model1
result = view3d->pick(225, 175);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.distance(), 550.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.75f, 0.75f));
QCOMPARE(result.scenePosition(), QVector3D(25.0f, 25.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(25.0f, 25.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Pick one specific based on viewport position
// Center of model1, overlapping model2,
// only check for model2, so should hit model2
result = view3d->pick(200, 200, model2);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.distance(), 600.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.0f, 0.0f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 0.0f));
QCOMPARE(result.position(), QVector3D(-50.0f, -50.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// The bottom right of instancedModel,
// overlapped model1 and then model2,
// only check for instancedModel, should hit instancedModel
result = view3d->pick(225, 175, instancedModel);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), instancedModel);
QCOMPARE(result.distance(), 650.0f);
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 0.0f));
QCOMPARE(result.scenePosition(), QVector3D(25.0f, 25.0f, -50.0f));
QCOMPARE(result.position(), QVector3D(50.0f, -50.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 1);
QCOMPARE(result.itemHit(), nullptr);
// Pick subset based on viewport position
// Upper right corner of model1, center of model2
// Check for model2 only
// Should hit model2, ignore model1
QJSEngine engine;
QJSValue array = engine.newArray(1);
array.setProperty(0, engine.newQObject(model2));
auto resultList = view3d->pickSubset(250, 150, array);
QCOMPARE(resultList.size(), 1);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[0].objectHit(), model2);
QCOMPARE(resultList[0].distance(), 600.0f);
QCOMPARE(resultList[0].uvPosition(), QVector2D(0.5f, 0.5f));
QCOMPARE(resultList[0].scenePosition(), QVector3D(50.0f, 50.0f, 0.0f));
QCOMPARE(resultList[0].position(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(resultList[0].sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[0].normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[0].instanceIndex(), 0);
QCOMPARE(resultList[0].itemHit(), nullptr);
// The bottom right of instancedModel,
// overlapped model1 and then model2,
// Check for both model2 and instancedModel
// Should hit both and ignore model1
array = engine.newArray(2);
array.setProperty(0, engine.newQObject(model2));
array.setProperty(1, engine.newQObject(instancedModel));
resultList = view3d->pickSubset(225, 175, array);
QCOMPARE(resultList.size(), 2);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[0].objectHit(), model2);
QCOMPARE(resultList[0].distance(), 600.0f);
QCOMPARE(resultList[0].uvPosition(), QVector2D(0.25f, 0.25f));
QCOMPARE(resultList[0].scenePosition(), QVector3D(25.0f, 25.0f, 0.0f));
QCOMPARE(resultList[0].position(), QVector3D(-25.0f, -25.0f, 50.0f));
QCOMPARE(resultList[0].sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[0].normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[0].instanceIndex(), 0);
QCOMPARE(resultList[0].itemHit(), nullptr);
QCOMPARE(resultList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[1].objectHit(), instancedModel);
QCOMPARE(resultList[1].distance(), 650.0f);
QCOMPARE(resultList[1].uvPosition(), QVector2D(1.0f, 0.0f));
QCOMPARE(resultList[1].scenePosition(), QVector3D(25.0f, 25.0f, -50.0f));
QCOMPARE(resultList[1].position(), QVector3D(50.0f, -50.0f, 50.0f));
QCOMPARE(resultList[1].sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[1].normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(resultList[1].instanceIndex(), 1);
QCOMPARE(resultList[1].itemHit(), nullptr);
// Enable the 2D item
item2d->setEnabled(true);
QVERIFY(waitForFrames(view.data(), 1));
// Then picking on top of model1 should not pick it anymore
result = view3d->pick(200, 200);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2d);
QCOMPARE(result.distance(), 400.0f);
QCOMPARE(result.uvPosition(), QVector2D(75.0f, 75.0f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 200.0f));
QCOMPARE(result.position(), QVector3D(0.0f, 0.0f, 0.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), -1);
QCOMPARE(result.objectHit(), nullptr);
// Hide the 2D item
item2d->setVisible(false);
QVERIFY(waitForFrames(view.data(), 1));
// Then picking on top of model1 should pick it again
result = view3d->pick(200, 200);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
// Pick all based on viewport position
// Center of model1, bottom left corner of model2
resultList = view3d->pickAll(200, 200);
QCOMPARE(resultList.size(), 2);
QCOMPARE(resultList[0].objectHit(), model1);
QCOMPARE(resultList[1].objectHit(), model2);
// Add the 2D item
item2d->setVisible(true);
QVERIFY(waitForFrames(view.data(), 1));
resultList = view3d->pickAll(200, 200);
QCOMPARE(resultList.size(), 3);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultList[0].itemHit(), item2d);
QCOMPARE(resultList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[1].objectHit(), model1);
QCOMPARE(resultList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[2].objectHit(), model2);
// Hide the 2D item
item2d->setVisible(false);
QVERIFY(waitForFrames(view.data(), 1));
// Top right corner of model1, center of model2
resultList = view3d->pickAll(250, 150);
QCOMPARE(resultList.size(), 2);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[0].objectHit(), model1);
QCOMPARE(resultList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[1].objectHit(), model2);
// Just outside model1's upper right corner, so should hit the model behind (model2)
resultList = view3d->pickAll(251, 151);
QCOMPARE(resultList.size(), 1);
QCOMPARE(resultList[0].objectHit(), model2);
// The bottom right of the second entry in the instance table,
// overlapping model1 and model2
resultList = view3d->pickAll(225, 175);
QCOMPARE(resultList.size(), 3);
QCOMPARE(resultList[0].objectHit(), model1);
QCOMPARE(resultList[1].objectHit(), model2);
QCOMPARE(resultList[2].objectHit(), instancedModel);
QCOMPARE(resultList[2].instanceIndex(), 1);
// Just outside model2's upper right corner, so there should be no hit
resultList = view3d->pickAll(301, 99);
QVERIFY(resultList.isEmpty());
}
void tst_Picking::test_ray_picking()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("picking.qml"), QSize(400, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
QQuick3DModel *model2 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model2"));
QVERIFY(model2);
QQuick3DModel *instancedModel = view3d->findChild<QQuick3DModel *>(QStringLiteral("instancedModel"));
QVERIFY(instancedModel);
QQuickItem *item2d = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dNode", "item2d"));
QVERIFY(item2d);
item2d->setEnabled(true);
item2d->setVisible(true);
QVERIFY(waitForFrames(view.data(), 1));
// Ray based picking one result
// Down the z axis from 0,0,100 (towards 0,0,0)
QVector3D origin(0.0f, 0.0f, 100.0f);
QVector3D direction(0.0f, 0.0f, -1.0f);
auto result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.distance(), 50.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.5f, 0.5f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Down the z axis from 0,0,250 (towards 0,0,0) through the item2d
origin = QVector3D(0.0f, 0.0f, 250.0f);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2d);
QCOMPARE(result.distance(), 50.0f);
QCOMPARE(result.uvPosition(), QVector2D(75.0f, 75.0f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 200.0f));
QCOMPARE(result.position(), QVector3D(0.0f, 0.0f, 0.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), -1);
QCOMPARE(result.objectHit(), nullptr);
// Up the z axis from 0, 0, -101 (towards 0,0,0)
origin = QVector3D(0.0f, 0.0f, -101.0f);
direction = QVector3D(0.0f, 0.0f, 1.0f);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.distance(), 1.0f);
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 0.0f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, -100.0f));
QCOMPARE(result.position(), QVector3D(-50.0f, -50.0f, -50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Up the z axis from 0, 0, -100 (towards 0,0,-1000)
origin = QVector3D(0.0f, 0.0f, -100.0f);
direction = QVector3D(0.0f, 0.0f, -1.0f);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QCOMPARE(result.objectHit(), nullptr);
QCOMPARE(result.itemHit(), nullptr);
// Ray based picking all results
// Down the z axis from 0,0,250 (towards 0,0,0)
origin = QVector3D(0.0f, 0.0f, 250.0f);
direction = QVector3D(0.0f, 0.0f, -1.0f);
auto resultList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultList.size(), 3);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultList[0].itemHit(), item2d);
QCOMPARE(resultList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[1].objectHit(), model1);
QCOMPARE(resultList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[2].objectHit(), model2);
QVector3D hitPoint = resultList[2].scenePosition();
// Test ray picking only model 2
result = view3d->rayPick(origin, direction, model2);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.scenePosition(), hitPoint);
// Up the z axis from 0, 0, -101 (towards 0,0,0)
origin = QVector3D(0.0f, 0.0f, -101.0f);
direction = QVector3D(0.0f, 0.0f, 1.0f);
resultList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultList.size(), 2);
QCOMPARE(resultList[0].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[0].objectHit(), model2);
QCOMPARE(resultList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultList[1].objectHit(), model1);
// Up the z axis from 0, 0, -100 (towards 0,0,-1000)
origin = QVector3D(0.0f, 0.0f, -100.0f);
direction = QVector3D(0.0f, 0.0f, -1.0f);
resultList = view3d->rayPickAll(origin, direction);
QVERIFY(resultList.isEmpty());
}
void tst_Picking::test_object_picking2()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("picking2.qml"), QSize(100, 100)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
const qreal dpr = view->devicePixelRatio();
if (dpr != 1.0) {
QSKIP("Test uses window positions to get exact values and those assume DPR of 1.0");
}
const auto viewSize = view->size();
const float halfWidth = viewSize.width() * 0.5f;
const float halfHeight = viewSize.height() * 0.5f;
const float horizontalPickLine = halfHeight - 35;
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *coneModel = view3d->findChild<QQuick3DModel *>(QStringLiteral("model3"));
QVERIFY(coneModel);
// just left of the cone (model3)
auto result = view3d->pick(halfWidth - 11, horizontalPickLine);
QCOMPARE(result.objectHit(), nullptr);
// center top of the cone (model3)
result = view3d->pick(halfWidth, horizontalPickLine);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), coneModel);
// just right of the cone (model3)
result = view3d->pick(halfWidth + 11, horizontalPickLine);
QCOMPARE(result.objectHit(), nullptr);
}
// Necessary for doing comparisons of normalized vectors
static bool fuzzyCompareVectors(const QVector3D& v1, const QVector3D& v2, float epsilon = 0.000001f) {
return std::abs(v1.x() - v2.x()) < epsilon &&
std::abs(v1.y() - v2.y()) < epsilon &&
std::abs(v1.z() - v2.z()) < epsilon;
}
void tst_Picking::test_item_picking()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("item_picking.qml"), QSize(400, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
QQuick3DModel *model2 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model2"));
QVERIFY(model2);
QQuickItem *item2dPlusZ = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dPlusZNode", "item2dPlusZ"));
QVERIFY(item2dPlusZ);
QQuickItem *item2dMinusZ = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dMinusZNode", "item2dMinusZ"));
QVERIFY(item2dMinusZ);
QQuickItem *item2dPlusX = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dPlusXNode", "item2dPlusX"));
QVERIFY(item2dPlusX);
QQuickItem *item2dMinusX = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dMinusXNode", "item2dMinusX"));
QVERIFY(item2dMinusX);
QQuickItem *item2dPlusY = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dPlusYNode", "item2dPlusY"));
QVERIFY(item2dPlusY);
QQuickItem *item2dMinusY = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dMinusYNode", "item2dMinusY"));
QVERIFY(item2dMinusY);
QQuickItem *item2dRotation = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dRotationNode", "item2dRotation"));
QVERIFY(item2dRotation);
QQuickItem *item2dTranslation = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dTranslationNode", "item2dTranslation"));
QVERIFY(item2dTranslation);
QQuickItem *item2dScale = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dScaleNode", "item2dScale"));
QVERIFY(item2dScale);
QQuickItem *item2dComplex = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dComplexNode", "item2dComplex"));
QVERIFY(item2dComplex);
QQuickItem *item2dMadness = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dMadnessNode", "item2dMadness"));
QVERIFY(item2dMadness);
// These tests intentionally try to cast rays into nothing, to check that item2ds picking stays within the bounds of the items
// This is necessary since items2ds uses plane intersection for ray collision tests
// Z Axes
auto origin = QVector3D(200, 200, 200);
auto direction = QVector3D(0, 0, -1);
auto result = view3d->rayPick(origin, direction);
auto resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
origin = QVector3D(200, 200, -200);
direction = QVector3D(0, 0, -1);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// X Axes
origin = QVector3D(200, 200, 200);
direction = QVector3D(-1, 0, 0);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
origin = QVector3D(-200, 200, 200);
direction = QVector3D(1, 0, 0);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// Y Axes
origin = QVector3D(200, 200, 200);
direction = QVector3D(0, -1, 0);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
origin = QVector3D(200, -200, 200);
direction = QVector3D(0, 1, 0);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// These tests all cast a ray down from above
direction = QVector3D (0, -1, 0);
// Rotation
origin = QVector3D(250, 100, -50);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// Translation
origin = QVector3D(450, 100, 10);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// Scale
origin = QVector3D(700, 100, 110);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// Complex
origin = QVector3D(900, 100, 110);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// Madness (fake 3D transforms in 2D)
origin = QVector3D(1150, 100, 90);
result = view3d->rayPick(origin, direction);
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
QVERIFY(resultsList.isEmpty());
// The following tests try to hit the item2ds
// NB: Only a front-face hit of an item2d should count as a hit
// +Z
origin = QVector3D(25, 25, 200);
direction = QVector3D(0, 0, -1);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dPlusZ);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 0, 1)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dPlusZ);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model1);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model2);
// -Z
// NB: In this case the distance of collision should be the exact same for both
// model2 and item2dMinusZ. Item2D collision always occurs first, so it should
// be the first in the list.
origin = QVector3D(25, 25, -200);
direction = QVector3D(0, 0, 1);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dMinusZ);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 0, -1)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dMinusZ);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model2);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model1);
QCOMPARE(resultsList[0].distance(), resultsList[1].distance());
// +X
// NB: in this case the distance of collision should be the exact same for both
// model2 and item2dPlusX. Item2D collision always occurs first, so it should
// be the first in the list.
origin = QVector3D(200, 25, -25);
direction = QVector3D(-1, 0, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dPlusX);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(1, 0, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dPlusX);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model2);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model1);
QCOMPARE(resultsList[0].distance(), resultsList[1].distance());
// -X
origin = QVector3D(-200, 25, -25);
direction = QVector3D(1, 0, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dMinusX);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(-1, 0, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dMinusX);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model1);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model2);
// +Y
// NB: in this case the distance of collision should be the exact same for both
// model2 and item2dPlusY. Item2D collision always occurs first, so it should
// be the first in the list.
origin = QVector3D(25, 200, -25);
direction = QVector3D(0, -1, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dPlusY);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dPlusY);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model2);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model1);
QCOMPARE(resultsList[0].distance(), resultsList[1].distance());
// -Y
origin = QVector3D(25, -200, -25);
direction = QVector3D(0, 1, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dMinusY);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, -1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 3);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dMinusY);
QCOMPARE(resultsList[1].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[1].objectHit(), model1);
QCOMPARE(resultsList[2].hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(resultsList[2].objectHit(), model2);
// The transform tests are aligned to the XZ plane, so all directions
// will be down the Y axis
direction = QVector3D(0, -1, 0);
// Rotation
origin = QVector3D(300, 100, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dRotation);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 1);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dRotation);
// Translate
origin = QVector3D(450, 100, -50);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dTranslation);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 1);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dTranslation);
// Scale
origin = QVector3D(700, 100, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dScale);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 1);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dScale);
// Complex
origin = QVector3D(900, 100, 0);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dComplex);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 1);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dComplex);
// Madness
origin = QVector3D(1150, 100, 50);
result = view3d->rayPick(origin, direction);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(result.itemHit(), item2dMadness);
QVERIFY(fuzzyCompareVectors(result.sceneNormal(), QVector3D(0, 1, 0)));
resultsList = view3d->rayPickAll(origin, direction);
QCOMPARE(resultsList.size(), 1);
QCOMPARE(resultsList[0].hitType(), QQuick3DPickResultEnums::HitType::Item);
QCOMPARE(resultsList[0].itemHit(), item2dMadness);
}
// When triangles become so small the picking algorithm fails because of floating point
// precision. This test generates a quad with count * count subdivisions leading to smaller
// and smaller triangles to pick against. Even if a mesh is very dense, the triangle intersection
// code should still work and return model1 as a hit.
void tst_Picking::test_picking_QTBUG_111997()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("qtbug_111997.qml"), QSize(100, 100)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
const auto viewSize = view->size();
const float halfWidth = viewSize.width() * 0.5f;
const float halfHeight = viewSize.height() * 0.5f;
// Add custom geometry to the scene
QScopedPointer<CustomGeometry> geometry(new CustomGeometry(20));
geometry->setParent(model1);
geometry->setParentItem(model1);
model1->setGeometry(geometry.data());
// Check picking with 20 subdivisions
QVERIFY(waitForFrames(view.data(), 2));
auto result = view3d->pick(halfWidth, halfHeight);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
// check picking with 350 subdivisions
geometry->setCount(350);
QVERIFY(waitForFrames(view.data(), 2));
result = view3d->pick(halfWidth, halfHeight);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
// check picking with 500 subdivisions
geometry->setCount(500);
QVERIFY(waitForFrames(view.data(), 2));
result = view3d->pick(halfWidth, halfHeight);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
}
void tst_Picking::test_sphere_geometry()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("pickable_sphere.qml"), QSize(100, 100)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
const auto viewSize = view->size();
const float halfWidth = viewSize.width() * 0.5f;
const float halfHeight = viewSize.height() * 0.5f;
// Wait for a couple of frames (so that geometry is up-to-date)
QVERIFY(waitForFrames(view.data(), 2));
auto result = view3d->pick(halfWidth, halfHeight);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
}
void tst_Picking::test_picking_corner_case()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("corner_case.qml"), QSize(400, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
const QVector3D direction = QVector3D(0.0f, 0.0f, 1.0f);
{
// bottom right corner (vertex)
const QVector3D origin1 = QVector3D(0.0f, 0.0f, -101.0f);
const QVector3D origin2 = QVector3D(0.0f, 0.0f, -100.0f);
auto result = view3d->rayPick(origin1, direction);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), origin2);
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 0.0f));
// The ray doesn't intersect the triangle as the origin
// starts on the triangle
// The ray intersects with the other face of the cube,
// but unless we test for backfaces the test should still
result = view3d->rayPick(origin2, direction);
QVERIFY(result.objectHit() == nullptr);
}
{
// top right corner (vertex)
const QVector3D origin1 = QVector3D(0.0f, 100.0f, -101.0f);
const QVector3D origin2 = QVector3D(0.0f, 100.0f, -100.0f);
auto result = view3d->rayPick(origin1, direction);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), origin2);
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.uvPosition(), QVector2D(1.0f, 1.0f));
// The ray doesn't intersect the triangle as the origin
// starts on the triangle
// The ray intersects with the other face of the cube,
// but unless we test for backfaces the test should still
result = view3d->rayPick(origin2, direction);
QVERIFY(result.objectHit() == nullptr);
}
{
// bottom left corner (vertex)
const QVector3D origin1 = QVector3D(100.0f, 0.0f, -101.0f);
const QVector3D origin2 = QVector3D(100.0f, 0.0f, -100.0f);
auto result = view3d->rayPick(origin1, direction);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), origin2);
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.uvPosition(), QVector2D(0.0f, 0.0f));
// The ray doesn't intersect the triangle as the origin
// starts on the triangle
// The ray intersects with the other face of the cube,
// but unless we test for backfaces the test should still
result = view3d->rayPick(origin2, direction);
QVERIFY(result.objectHit() == nullptr);
}
{
// top left corner (vertex)
const QVector3D origin1 = QVector3D(100.0f, 100.0f, -101.0f);
const QVector3D origin2 = QVector3D(100.0f, 100.0f, -100.0f);
auto result = view3d->rayPick(origin1, direction);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), origin2);
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.uvPosition(), QVector2D(0.0f, 1.0f));
// The ray doesn't intersect the triangle as the origin
// starts on the triangle
// The ray intersects with the other face of the cube,
// but unless we test for backfaces the test should still
result = view3d->rayPick(origin2, direction);
QVERIFY(result.objectHit() == nullptr);
}
{
// Center
const QVector3D origin1 = QVector3D(50.0f, 50.0f, -101.0f);
const QVector3D origin2 = QVector3D(50.0f, 50.0f, -100.0f);
auto result = view3d->rayPick(origin1, direction);
QVERIFY(result.objectHit() != nullptr);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), origin2);
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, -1.0f));
QCOMPARE(result.uvPosition(), QVector2D(0.5f, 0.5f));
// The ray doesn't intersect the triangle as the origin
// starts on the triangle
// The ray intersects with the other face of the cube,
// but unless we test for backfaces the test should still
result = view3d->rayPick(origin2, direction);
QVERIFY(result.objectHit() == nullptr);
}
}
void tst_Picking::test_triangleIntersect()
{
const QVector3D direction(0, 0, -1);
const QVector3D expectedNormal(0, 0, 1);
const QVector3D vert0(0, 0, 0);
const QVector3D vert1(-1, -1, 0);
const QVector3D vert2(1, -1, 0);
QVector3D normal;
float u;
float v;
bool intersects;
const QVector3D origin1(0, 0, 2);
const QSSGRenderRay ray1(origin1, direction); // intersection vert0
intersects = QSSGRenderRay::triangleIntersect(ray1,
vert0,
vert1,
vert2,
u,
v,
normal);
QVERIFY(intersects);
QCOMPARE(normal, expectedNormal);
QCOMPARE(u, 0.0f);
QCOMPARE(v, 0.0f);
const QVector3D origin2(-1, -1, 2);
const QSSGRenderRay ray2(origin2, direction); // intersection vert1
intersects = QSSGRenderRay::triangleIntersect(ray2,
vert0,
vert1,
vert2,
u,
v,
normal);
QVERIFY(intersects);
QCOMPARE(normal, expectedNormal);
QCOMPARE(u, 1.0f);
QCOMPARE(v, 0.0f);
const QVector3D origin3(1, -1, 2);
const QSSGRenderRay ray3(origin3, direction); // intersection vert2
intersects = QSSGRenderRay::triangleIntersect(ray3,
vert0,
vert1,
vert2,
u,
v,
normal);
QVERIFY(intersects);
QCOMPARE(normal, expectedNormal);
QCOMPARE(u, 0.0f);
QCOMPARE(v, 1.0f);
}
void tst_Picking::test_closest_point_picking()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("picking.qml"), QSize(400, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
QQuick3DModel *model1 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model1"));
QVERIFY(model1);
QQuick3DModel *model2 = view3d->findChild<QQuick3DModel *>(QStringLiteral("model2"));
QVERIFY(model2);
QQuick3DModel *instancedModel = view3d->findChild<QQuick3DModel *>(QStringLiteral("instancedModel"));
QVERIFY(instancedModel);
QQuickItem *item2d = qmlobject_cast<QQuickItem *>(find2DChildIn3DNode(view.data(), "item2dNode", "item2d"));
QVERIFY(item2d);
item2d->setEnabled(true);
item2d->setVisible(true);
QVERIFY(waitForFrames(view.data(), 1));
// model1 is a unit cube at (0,0,0), so it has a surface point at (0, 0, 50)
QVector3D origin;
// Model outside radius
origin = QVector3D(0.0f, 0.0f, 70.0f);
auto result = view3d->closestPointPick(origin, 10);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Null);
result = view3d->closestPointPick(origin, 30);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.distance(), 20.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.5f, 0.5f));
QCOMPARE(result.scenePosition(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.position(), QVector3D(0.0f, 0.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Test hit on edge. It's not specified which face it should choose, so ignore
// normals and UVs. model1 has an edge that passes through (-50, -50, 0)
origin = QVector3D(-70.0f, -70.0f, 0.0f); // distance == sqrt(20^2 + 20^2) < 30
result = view3d->closestPointPick(origin, 30, model1);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model1);
QCOMPARE(result.scenePosition(), QVector3D(-50.0f, -50.0f, 0.0f));
QVERIFY(qFuzzyCompare(result.distance(), float(sqrt(800.0f))));
// model2 is a unit cube at (50, 50, -50), so it has a surface point at (10, 10, 0)
// Check to see that we return the specified model, even if model1 is closer
origin = QVector3D(10.0f, 10.0f, 70.0f);
result = view3d->closestPointPick(origin, 100, model2);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), model2);
QCOMPARE(result.distance(), 70.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.1f, 0.1f));
QCOMPARE(result.scenePosition(), QVector3D(10.0f, 10.0f, 0.0f));
QCOMPARE(result.position(), QVector3D(-40.0f, -40.0f, 50.0f));
QCOMPARE(result.sceneNormal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.normal(), QVector3D(0.0f, 0.0f, 1.0f));
QCOMPARE(result.instanceIndex(), 0);
QCOMPARE(result.itemHit(), nullptr);
// Test instanced picking
// Instance index 2 describes a unit cube at (200, 0, 0), so it has a surface
// point at (150, 0, 0) with a normal of (-1, 0, 0)
origin = QVector3D(140.0f, 0.0f, 0.0f);
result = view3d->closestPointPick(origin, 20);
QCOMPARE(result.hitType(), QQuick3DPickResultEnums::HitType::Model);
QCOMPARE(result.objectHit(), instancedModel);
QCOMPARE(result.distance(), 10.0f);
QCOMPARE(result.uvPosition(), QVector2D(0.5f, 0.5f));
QCOMPARE(result.scenePosition(), QVector3D(150.0f, 0.0f, 0.0f));
QCOMPARE(result.position(), QVector3D(-50.0f, 0.0f, 0.0f));
QCOMPARE(result.sceneNormal(), QVector3D(-1.0f, 0.0f, 0.0f));
QCOMPARE(result.normal(), QVector3D(-1.0f, 0.0f, 0.0f));
QCOMPARE(result.instanceIndex(), 2);
QCOMPARE(result.itemHit(), nullptr);
}
void tst_Picking::test_triangleIntersect_cullMode_data()
{
QTest::addColumn<QVector3D>("origin");
QTest::addColumn<QVector3D>("direction");
QTest::addColumn<QSSGCullFaceMode>("cullMode");
QTest::addColumn<bool>("expectedIntersects");
// The triangle below faces +Z
const QVector3D frontOrigin(0.0f, -0.5f, 2.0f);
const QVector3D frontDirection(0.0f, 0.0f, -1.0f);
const QVector3D backOrigin(0.0f, -0.5f, -2.0f);
const QVector3D backDirection(0.0f, 0.0f, 1.0f);
QTest::newRow("front_backFaceCulling") << frontOrigin << frontDirection << QSSGCullFaceMode::Back << true;
QTest::newRow("front_frontFaceCulling") << frontOrigin << frontDirection << QSSGCullFaceMode::Front << false;
QTest::newRow("front_noCulling") << frontOrigin << frontDirection << QSSGCullFaceMode::Disabled << true;
QTest::newRow("front_frontAndBackCulling") << frontOrigin << frontDirection << QSSGCullFaceMode::FrontAndBack << false;
QTest::newRow("back_backFaceCulling") << backOrigin << backDirection << QSSGCullFaceMode::Back << false;
QTest::newRow("back_frontFaceCulling") << backOrigin << backDirection << QSSGCullFaceMode::Front << true;
QTest::newRow("back_noCulling") << backOrigin << backDirection << QSSGCullFaceMode::Disabled << true;
QTest::newRow("back_frontAndBackCulling") << backOrigin << backDirection << QSSGCullFaceMode::FrontAndBack << false;
}
void tst_Picking::test_triangleIntersect_cullMode()
{
QFETCH(QVector3D, origin);
QFETCH(QVector3D, direction);
QFETCH(QSSGCullFaceMode, cullMode);
QFETCH(bool, expectedIntersects);
const QVector3D vert0(0, 0, 0);
const QVector3D vert1(-1, -1, 0);
const QVector3D vert2(1, -1, 0);
QVector3D normal;
float u = 0.0f;
float v = 0.0f;
const QSSGRenderRay ray(origin, direction);
const bool intersects = QSSGRenderRay::triangleIntersect(ray, vert0, vert1, vert2, u, v, normal, cullMode);
QCOMPARE(intersects, expectedIntersects);
if (!intersects)
return;
QVERIFY(u >= 0.0f && u <= 1.0f);
QVERIFY(v >= 0.0f && v <= 1.0f);
QVERIFY(u + v <= 1.0f);
QCOMPARE(normal, QVector3D(0.0f, 0.0f, 1.0f));
}
void tst_Picking::test_picking_cull_mode()
{
QScopedPointer<QQuickView> view(createView(QLatin1String("cull_mode.qml"), QSize(600, 400)));
QVERIFY(view);
QVERIFY(QTest::qWaitForWindowExposed(view.data()));
QQuick3DViewport *view3d = view->findChild<QQuick3DViewport *>(QStringLiteral("view"));
QVERIFY(view3d);
const QImage rendered = grab(view.data());
if (rendered.isNull())
return; // was QFAIL'ed already
const qreal dpr = view->devicePixelRatio();
struct CullModeCase
{
const char *objectName;
QPoint viewportPos;
QColor renderedColor; // The clear color when the visible side is culled away
bool pickable;
};
// Whatever is culled away when rendering must not be pickable, and whatever is
// rendered must be.
static const CullModeCase cases[] = {
{ "backCull", QPoint(100, 100), QColor(Qt::black), false },
{ "frontCull", QPoint(300, 100), QColor(0, 255, 0), true },
{ "noCull", QPoint(500, 100), QColor(0, 0, 255), true },
{ "mirrorBackCull", QPoint(100, 300), QColor(Qt::black), false },
{ "mirrorFrontCull", QPoint(300, 300), QColor(0, 255, 255), true },
{ "mirrorNoCull", QPoint(500, 300), QColor(255, 0, 255), true },
};
for (const CullModeCase &c : cases) {
QQuick3DModel *model = view3d->findChild<QQuick3DModel *>(QLatin1String(c.objectName));
QVERIFY2(model, c.objectName);
QVERIFY2(comparePixel(rendered, c.viewportPos, dpr, c.renderedColor, 5), c.objectName);
const QQuick3DPickResult result = view3d->pick(c.viewportPos.x(), c.viewportPos.y());
if (c.pickable)
QVERIFY2(result.objectHit() == model, c.objectName);
else
QVERIFY2(result.objectHit() == nullptr, c.objectName);
}
}
QTEST_MAIN(tst_Picking)
#include "tst_picking.moc"