Revision control
++ // Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "qmlscenereader.h"
++ #include "testarbiter.h"
++
++ #include <QUrl>
++
++ #include <QtTest/QTest>
++ #include <Qt3DCore/qentity.h>
++ #include <Qt3DCore/qtransform.h>
++ #include <Qt3DCore/private/qaspectjobmanager_p.h>
++ #include <Qt3DCore/private/qnodevisitor_p.h>
++ #include <Qt3DCore/private/calcboundingvolumejob_p.h>
++ #include <QtQuick/qquickwindow.h>
++
++ #include <Qt3DRender/QCamera>
++ #include <Qt3DRender/QObjectPicker>
++ #include <Qt3DRender/QPickEvent>
++ #include <Qt3DRender/QPickTriangleEvent>
++ #include <Qt3DRender/private/nodemanagers_p.h>
++ #include <Qt3DRender/private/managers_p.h>
++ #include <Qt3DRender/private/entity_p.h>
++ #include <Qt3DRender/qrenderaspect.h>
++ #include <Qt3DRender/private/qrenderaspect_p.h>
++ #include <Qt3DRender/private/pickboundingvolumejob_p.h>
++ #include <Qt3DRender/private/updateworldboundingvolumejob_p.h>
++ #include <Qt3DRender/private/updateworldtransformjob_p.h>
++ #include <Qt3DRender/private/expandboundingvolumejob_p.h>
++ #include <Qt3DRender/private/calcboundingvolumejob_p.h>
++ #include <Qt3DRender/private/buffermanager_p.h>
++ #include <Qt3DRender/private/geometryrenderermanager_p.h>
++ #include <Qt3DRender/private/sphere_p.h>
++
++ #include <qbackendnodetester.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace Qt3DRender {
++
++ QList<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
++ {
++ using namespace Qt3DCore;
++
++ QList<QNode *> nodes;
++ Qt3DCore::QNodeVisitor visitor;
++ visitor.traverse(root, [&nodes](QNode *node) {
++ nodes.append(node);
++
++ // Store the metaobject of the node in the QNode so that we have it available
++ // to us during destruction in the QNode destructor. This allows us to send
++ // the QNodeId and the metaobject as typeinfo to the backend aspects so they
++ // in turn can find the correct QBackendNodeMapper object to handle the destruction
++ // of the corresponding backend nodes.
++ QNodePrivate *d = QNodePrivate::get(node);
++ d->m_typeInfo = const_cast<QMetaObject*>(QNodePrivate::findStaticMetaObject(node->metaObject()));
++
++ // Mark this node as having been handled for creation so that it is picked up
++ d->m_hasBackendNode = true;
++ });
++
++ return nodes;
++ }
++
++ QList<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QList<Qt3DCore::QNode *> nodes)
++ {
++ QList<Qt3DCore::NodeTreeChange> nodeTreeChanges;
++ nodeTreeChanges.reserve(nodes.size());
++
++ for (Qt3DCore::QNode *n : nodes) {
++ nodeTreeChanges.push_back({
++ n->id(),
++ Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
++ Qt3DCore::NodeTreeChange::Added,
++ n
++ });
++ }
++
++ return nodeTreeChanges;
++ }
++
++ class TestAspect : public Qt3DRender::QRenderAspect, public Qt3DCore::QAbstractFrontEndNodeManager
++ {
++ public:
++ TestAspect(Qt3DCore::QNode *root)
++ : Qt3DRender::QRenderAspect()
++ , m_sceneRoot(nullptr)
++ {
++ QRenderAspect::onRegistered();
++ m_root = qobject_cast<Qt3DCore::QEntity *>(root);
++
++ const QList<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
++ const QList<Qt3DCore::NodeTreeChange> nodeTreeChanges = nodeTreeChangesForNodes(nodes);
++ d_func()->setRootAndCreateNodes(m_root, nodeTreeChanges);
++
++ Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
++ Q_ASSERT(rootEntity);
++ m_sceneRoot = rootEntity;
++ }
++
++ ~TestAspect()
++ {
++ QRenderAspect::onUnregistered();
++ }
++
++ void onRegistered() override { QRenderAspect::onRegistered(); }
++ void onUnregistered() override { QRenderAspect::onUnregistered(); }
++
++ Qt3DRender::Render::NodeManagers *nodeManagers() const { return d_func()->m_renderer->nodeManagers(); }
++ Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const { return d_func()->m_renderer->frameGraphRoot(); }
++ Qt3DRender::Render::RenderSettings *renderSettings() const { return d_func()->m_renderer->settings(); }
++ Qt3DCore::QEntity *root() const { return m_root; }
++ Qt3DRender::Render::Entity *sceneRoot() const { return m_sceneRoot; }
++ Qt3DRender::Render::AbstractRenderer *renderer() const { return d_func()->m_renderer; }
++
++ void registerNode(Qt3DCore::QNode *node) { m_frontEndNodes.insert(node->id(), node); }
++ void registerTree(Qt3DCore::QEntity *root) {
++ using namespace Qt3DCore;
++ QNodeVisitor visitor;
++ visitor.traverse(root, [](QNode *) {}, [this](QEntity *entity) {
++ registerNode(entity);
++ const auto &components = entity->components();
++ for (const auto &c : components)
++ registerNode(c);
++ });
++ }
++ Qt3DCore::QNode *lookupNode(Qt3DCore::QNodeId id) const override { return m_frontEndNodes.value(id, nullptr); }
++ QList<Qt3DCore::QNode *> lookupNodes(const QList<Qt3DCore::QNodeId> &ids) const override {
++ QList<Qt3DCore::QNode *> res;
++ for (const auto &id: ids) {
++ auto node = m_frontEndNodes.value(id, nullptr);
++ if (node)
++ res.push_back(node);
++ }
++ return res;
++ }
++
++ private:
++ Qt3DCore::QEntity *m_root;
++ Render::Entity *m_sceneRoot;
++ QHash<Qt3DCore::QNodeId, Qt3DCore::QNode *> m_frontEndNodes;
++ };
++
++ } // namespace Qt3DRender
++
++ QT_END_NAMESPACE
++
++ namespace {
++
++ void runRequiredJobs(Qt3DRender::TestAspect *test)
++ {
++ Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
++ updateWorldTransform.setRoot(test->sceneRoot());
++ updateWorldTransform.setManagers(test->nodeManagers());
++ updateWorldTransform.run();
++
++ Qt3DCore::CalculateBoundingVolumeJob calcCBVolume(nullptr);
++ calcCBVolume.setRoot(test->root());
++
++ Qt3DRender::Render::CalculateBoundingVolumeJobPtr calcRBVolume = Qt3DRender::Render::CalculateBoundingVolumeJobPtr::create();
++ calcRBVolume->setManagers(test->nodeManagers());
++ calcRBVolume->setFrontEndNodeManager(test);
++ calcRBVolume->setRoot(test->sceneRoot());
++
++ calcCBVolume.addWatcher(calcRBVolume);
++
++ calcCBVolume.run();
++ calcCBVolume.postFrame(nullptr);
++ calcRBVolume->run();
++
++ Qt3DRender::Render::UpdateWorldBoundingVolumeJob updateWorldBVolume;
++ updateWorldBVolume.setManager(test->nodeManagers()->renderNodesManager());
++ updateWorldBVolume.run();
++
++ Qt3DRender::Render::ExpandBoundingVolumeJob expandBVolume;
++ expandBVolume.setRoot(test->sceneRoot());
++ expandBVolume.setManagers(test->nodeManagers());
++ expandBVolume.run();
++ }
++
++ } // anonymous
++
++ class tst_BoundingSphere : public Qt3DCore::QBackendNodeTester
++ {
++ Q_OBJECT
++ private:
++
++ private Q_SLOTS:
++ void checkIsNull() {
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ QVERIFY(defaultSphere.isNull());
++ }
++
++ void remainsNotNullAfterTransform() {
++ QMatrix4x4 mat;
++ mat.translate(-5,-5,-5);
++ auto mMat = Matrix4x4(mat);
++ auto pointSphere = Qt3DRender::Render::Sphere(Vector3D(5.f,5.f,5.f),0.f);
++ pointSphere.transform(mMat);
++ QVERIFY(!pointSphere.isNull());
++ QVERIFY(pointSphere.center() == Vector3D(0.,0.,0));
++ QVERIFY(pointSphere.radius() == 0.f);
++ }
++
++ void remainsNullAfterTransform() {
++ QMatrix4x4 mat;
++ mat.translate(-5,-5,-5);
++ auto mMat = Matrix4x4(mat);
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ defaultSphere.transform(mMat);
++ QVERIFY(defaultSphere.isNull());
++ }
++
++ void expandToContainSphere() {
++ auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
++ auto secondValidSphere = Qt3DRender::Render::Sphere(Vector3D(10.f,10.f,10.f),1.f);
++ firstValidSphere.expandToContain(secondValidSphere);
++ QVERIFY(firstValidSphere.center()==Vector3D(0.f,0.f,0.f));
++ float dist = static_cast<float>((2 + sqrt(3.*(20)*(20)))/2.);
++ QVERIFY(qFuzzyCompare(firstValidSphere.radius(), dist));
++ }
++
++ void expandToContainSphereOneInvalid() {
++ auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ auto copiedSphere = firstValidSphere;
++ firstValidSphere.expandToContain(defaultSphere);
++ QVERIFY(firstValidSphere.center() == copiedSphere.center());
++ QCOMPARE(firstValidSphere.radius(), copiedSphere.radius());
++ QVERIFY(!firstValidSphere.isNull());
++ }
++
++ void expandToContainOtherSphereInvalid() {
++ auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ defaultSphere.expandToContain(firstValidSphere);
++ QVERIFY(defaultSphere.center() == firstValidSphere.center());
++ QCOMPARE(defaultSphere.radius(), firstValidSphere.radius());
++ QVERIFY(!defaultSphere.isNull());
++ }
++
++ void expandNullSphereWithNullSphere() {
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ auto otherDefaultSphere = Qt3DRender::Render::Sphere();
++ defaultSphere.expandToContain(otherDefaultSphere);
++ QVERIFY(defaultSphere.isNull());
++ }
++
++ void expandToContainPoint() {
++ auto firstValidSphere = Qt3DRender::Render::Sphere(Vector3D(-10.f,-10.f,-10.f),1.f);
++ firstValidSphere.expandToContain(Vector3D(0,0,0));
++ QVERIFY(!firstValidSphere.isNull());
++ float expectedRadius = static_cast<float>((1 + qSqrt(3.*(10)*(10)))/2.);
++ QVERIFY(qFuzzyCompare(firstValidSphere.radius(), expectedRadius));
++ }
++
++ void nullSphereExpandToContainPoint() {
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ defaultSphere.expandToContain(Vector3D(5,5,5));
++ QVERIFY(!defaultSphere.isNull());
++ QVERIFY(defaultSphere.center() == Vector3D(5,5,5));
++ QVERIFY(qFuzzyIsNull(defaultSphere.radius()));
++ }
++
++ void nullSphereExpandToOrigin() {
++ auto defaultSphere = Qt3DRender::Render::Sphere();
++ defaultSphere.expandToContain(Vector3D(0,0,0));
++ QVERIFY(!defaultSphere.isNull());
++ QVERIFY(defaultSphere.center() == Vector3D(0,0,0));
++ QVERIFY(qFuzzyIsNull(defaultSphere.radius()));
++ }
++
++ void ritterSphereCubePoints() {
++ QList<Vector3D> cubePts={
++ Vector3D(-0.5, -0.5, 0.5),
++ Vector3D( 0.5, -0.5, -0.5),
++ Vector3D(-0.5, 0.5, -0.5),
++ Vector3D( 0.5, 0.5, -0.5),
++ Vector3D(-0.5, -0.5, -0.5),
++ Vector3D( 0.5, -0.5, 0.5),
++ Vector3D(-0.5, 0.5, 0.5),
++ Vector3D( 0.5, 0.5, 0.5)
++ };
++ auto ritterSphere=Qt3DRender::Render::Sphere::fromPoints(cubePts);
++ QVERIFY(!ritterSphere.isNull());
++ QVERIFY(qFuzzyIsNull(ritterSphere.center().x()));
++ QVERIFY(qFuzzyIsNull(ritterSphere.center().y()));
++ QVERIFY(qFuzzyIsNull(ritterSphere.center().z()));
++ QVERIFY(qFuzzyCompare(ritterSphere.radius(), static_cast<float>(qSqrt(3)/2)));
++ }
++
++ void ritterSphereRandomPoints() {
++ QList<Vector3D> randomPts={
++ Vector3D(-81, 55, 46),
++ Vector3D(-91, -73, -42),
++ Vector3D(-50, -76, -77),
++ Vector3D(-40, 63, 58),
++ Vector3D(-28, -2, -57),
++ Vector3D(84, 17, 33),
++ Vector3D(53, 11, -49),
++ Vector3D(-7, -24, -86),
++ Vector3D(-89, 6, 76),
++ Vector3D(46, -18, -27)
++ };
++
++ auto ritterSphere = Qt3DRender::Render::Sphere::fromPoints(randomPts);
++ QVERIFY(!ritterSphere.isNull());
++ QVERIFY(qFuzzyCompare(ritterSphere.center().x(), 17.f));
++ QVERIFY(qFuzzyCompare(ritterSphere.center().y(), -29.5f));
++ QVERIFY(qFuzzyCompare(ritterSphere.center().z(), -22.0f));
++ QVERIFY(qFuzzyCompare(ritterSphere.radius(), 148.66152831179963f));
++ }
++
++ void ritterSphereOnePoint() {
++ QList<Vector3D> singlePt={
++ Vector3D(-0.5, -0.5, -0.5),
++ };
++ auto ritterSphere = Qt3DRender::Render::Sphere::fromPoints(singlePt);
++ QVERIFY(!ritterSphere.isNull());
++ QVERIFY(qFuzzyCompare(ritterSphere.center().x(), -0.5f));
++ QVERIFY(qFuzzyCompare(ritterSphere.center().y(), -0.5f));
++ QVERIFY(qFuzzyCompare(ritterSphere.center().z(), -0.5f));
++ QVERIFY(qFuzzyIsNull(ritterSphere.radius()));
++ }
++
++ void checkExtraGeometries_data()
++ {
++ QTest::addColumn<QString>("qmlFile");
++ QTest::addColumn<QVector3D>("sphereCenter");
++ QTest::addColumn<float>("sphereRadius");
++ QTest::newRow("SphereMesh") << "qrc:/sphere.qml" << QVector3D(0.f, 0.f, 0.f) << 1.f;
++ QTest::newRow("CubeMesh") << "qrc:/cube.qml" << QVector3D(0.f, 0.f, 0.f) << static_cast<float>(qSqrt(3.)/2.); // not weird at all
++ }
++
++ void checkExtraGeometries()
++ {
++ // GIVEN
++ QFETCH(QString, qmlFile);
++ QFETCH(QVector3D, sphereCenter);
++ QFETCH(float, sphereRadius);
++
++ QUrl qmlUrl(qmlFile);
++ QmlSceneReader sceneReader(qmlUrl);
++ QScopedPointer<Qt3DCore::QNode> root(qobject_cast<Qt3DCore::QNode *>(sceneReader.root()));
++ QVERIFY(root);
++
++ QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(root.data()));
++
++ // Runs Required jobs
++ test->registerTree(qobject_cast<Qt3DCore::QEntity *>(root.data()));
++ runRequiredJobs(test.data());
++
++ // THEN
++ QVERIFY(test->sceneRoot()->worldBoundingVolumeWithChildren());
++ const auto boundingSphere = test->sceneRoot()->worldBoundingVolumeWithChildren();
++ qDebug() << qmlFile << boundingSphere->radius() << boundingSphere->center();
++ QCOMPARE(boundingSphere->radius(), sphereRadius);
++
++ QVERIFY(qFuzzyIsNull(boundingSphere->center().x() - sphereCenter.x()));
++ QVERIFY(qFuzzyIsNull(boundingSphere->center().y() - sphereCenter.y()));
++ QVERIFY(qFuzzyIsNull(boundingSphere->center().z() - sphereCenter.z()));
++ }
++
++ void checkCustomGeometry_data()
++ {
++ QTest::addColumn<int>("drawVertexCount");
++ QTest::addColumn<int>("indexByteOffset");
++ QTest::addColumn<QVector3D>("expectedCenter");
++ QTest::addColumn<float>("expectedRadius");
++ QTest::addColumn<bool>("withPrimitiveRestart");
++ QTest::newRow("all") << 0 << 0 << QVector3D(0.0f, 0.0f, -75.0f) << 25.03997f << false;
++ QTest::newRow("first only") << 3 << 0 << QVector3D(0, 1, -100) << 1.0f << false;
++ QTest::newRow("second only") << 3 << int(3 * sizeof(ushort)) << QVector3D(0, -1, -50) << 1.0f << false;
++ QTest::newRow("all with primitive restart") << 0 << 0 << QVector3D(0.0f, 0.0f, -75.0f) << 25.03997f << true;
++ QTest::newRow("first only with primitive restart") << 4 << 0 << QVector3D(0, 1, -100) << 1.0f << true;
++ QTest::newRow("second only with primitive restart") << 4 << int(3 * sizeof(ushort)) << QVector3D(0, -1, -50) << 1.0f << true;
++ }
++
++ void checkCustomGeometry()
++ {
++ QFETCH(int, drawVertexCount);
++ QFETCH(int, indexByteOffset);
++ QFETCH(QVector3D, expectedCenter);
++ QFETCH(float, expectedRadius);
++ QFETCH(bool, withPrimitiveRestart);
++
++ // two triangles with different Z, and an index buffer
++ QByteArray vdata;
++ vdata.resize(6 * 3 * sizeof(float));
++ float *vp = reinterpret_cast<float *>(vdata.data());
++ *vp++ = -1.0f;
++ *vp++ = 1.0f;
++ *vp++ = -100.0f;
++ *vp++ = 0.0f;
++ *vp++ = 0.0f;
++ *vp++ = -100.0f;
++ *vp++ = 1.0f;
++ *vp++ = 1.0f;
++ *vp++ = -100.0f;
++
++ *vp++ = -1.0f;
++ *vp++ = -1.0f;
++ *vp++ = -50.0f;
++ *vp++ = 0.0f;
++ *vp++ = 0.0f;
++ *vp++ = -50.0f;
++ *vp++ = 1.0f;
++ *vp++ = -1.0f;
++ *vp++ = -50.0f;
++
++ QByteArray idata;
++ const int indexCount = withPrimitiveRestart ? 7 : 6;
++ idata.resize(indexCount * sizeof(ushort));
++ ushort *ip = reinterpret_cast<ushort *>(idata.data());
++ *ip++ = 0;
++ *ip++ = 1;
++ *ip++ = 2;
++ if (withPrimitiveRestart)
++ *ip++ = 65535;
++ *ip++ = 3;
++ *ip++ = 4;
++ *ip++ = 5;
++
++ QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity);
++ QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(entity.data()));
++ Qt3DCore::QBuffer *vbuffer = new Qt3DCore::QBuffer;
++ Qt3DCore::QBuffer *ibuffer = new Qt3DCore::QBuffer;
++
++ vbuffer->setData(vdata);
++ Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
++ vbufferBackend->setRenderer(test->renderer());
++ vbufferBackend->setManager(test->nodeManagers()->bufferManager());
++ simulateInitializationSync(vbuffer, vbufferBackend);
++
++ ibuffer->setData(idata);
++ Qt3DRender::Render::Buffer *ibufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(ibuffer->id());
++ ibufferBackend->setRenderer(test->renderer());
++ ibufferBackend->setManager(test->nodeManagers()->bufferManager());
++ simulateInitializationSync(ibuffer, ibufferBackend);
++
++ Qt3DCore::QGeometry *g = new Qt3DCore::QGeometry;
++ for (int i = 0; i < 2; ++i)
++ g->addAttribute(new Qt3DCore::QAttribute);
++
++ const QList<Qt3DCore::QAttribute *> attrs = g->attributes();
++ Qt3DCore::QAttribute *attr = attrs[0];
++ attr->setBuffer(vbuffer);
++ attr->setName(Qt3DCore::QAttribute::defaultPositionAttributeName());
++ attr->setVertexBaseType(Qt3DCore::QAttribute::Float);
++ attr->setVertexSize(3);
++ attr->setCount(6);
++ attr->setByteOffset(0);
++ attr->setByteStride(3 * sizeof(float));
++
++ attr = attrs[1];
++ attr->setBuffer(ibuffer);
++ attr->setAttributeType(Qt3DCore::QAttribute::IndexAttribute);
++ attr->setVertexBaseType(Qt3DCore::QAttribute::UnsignedShort);
++ attr->setVertexSize(1);
++ attr->setCount(indexCount);
++ attr->setByteOffset(indexByteOffset);
++
++ Qt3DRender::QGeometryRenderer *gr = new Qt3DRender::QGeometryRenderer;
++ gr->setVertexCount(drawVertexCount); // when 0, indexAttribute->count() is used instead
++ gr->setPrimitiveRestartEnabled(withPrimitiveRestart);
++ if (withPrimitiveRestart)
++ gr->setRestartIndexValue(65535);
++ gr->setGeometry(g);
++ entity->addComponent(gr);
++
++ Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
++ attr0Backend->setRenderer(test->renderer());
++ simulateInitializationSync(attrs[0], attr0Backend);
++ Qt3DRender::Render::Attribute *attr1Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[1]->id());
++ attr1Backend->setRenderer(test->renderer());
++ simulateInitializationSync(attrs[1], attr1Backend);
++
++ Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
++ gBackend->setRenderer(test->renderer());
++ simulateInitializationSync(g, gBackend);
++
++ Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
++ grBackend->setRenderer(test->renderer());
++ grBackend->setManager(test->nodeManagers()->geometryRendererManager());
++ simulateInitializationSync(gr, grBackend);
++
++ Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
++ entityBackend->setRenderer(test->renderer());
++ simulateInitializationSync(entity.data(), entityBackend);
++
++ test->registerTree(entity.data());
++
++ Qt3DCore::CalculateBoundingVolumeJob calcCBVolume(nullptr);
++ calcCBVolume.setRoot(test->root());
++ calcCBVolume.run();
++ calcCBVolume.postFrame(nullptr);
++
++ Qt3DRender::Render::CalculateBoundingVolumeJob calcRBVolume;
++ calcRBVolume.setManagers(test->nodeManagers());
++ calcRBVolume.setRoot(test->sceneRoot());
++ calcRBVolume.setFrontEndNodeManager(test.data());
++ calcRBVolume.run();
++
++ Vector3D center = entityBackend->localBoundingVolume()->center();
++ float radius = entityBackend->localBoundingVolume()->radius();
++ qDebug() << radius << center;
++
++ QCOMPARE(radius, expectedRadius);
++ QCOMPARE(center.x(), expectedCenter.x());
++ QCOMPARE(center.y(), expectedCenter.y());
++ QCOMPARE(center.z(), expectedCenter.z());
++ }
++
++ void checkCustomPackedGeometry()
++ {
++ int drawVertexCount = 6;
++ QVector3D expectedCenter(0.0f, 0.0f, -75.0f);
++ float expectedRadius = 25.03997f;
++
++ // two triangles with different Z
++ QByteArray vdata;
++ vdata.resize(6 * 3 * sizeof(float));
++ float *vp = reinterpret_cast<float *>(vdata.data());
++ *vp++ = -1.0f;
++ *vp++ = 1.0f;
++ *vp++ = -100.0f;
++ *vp++ = 0.0f;
++ *vp++ = 0.0f;
++ *vp++ = -100.0f;
++ *vp++ = 1.0f;
++ *vp++ = 1.0f;
++ *vp++ = -100.0f;
++
++ *vp++ = -1.0f;
++ *vp++ = -1.0f;
++ *vp++ = -50.0f;
++ *vp++ = 0.0f;
++ *vp++ = 0.0f;
++ *vp++ = -50.0f;
++ *vp++ = 1.0f;
++ *vp++ = -1.0f;
++ *vp++ = -50.0f;
++
++ QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity);
++ QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(entity.data()));
++ Qt3DCore::QBuffer *vbuffer = new Qt3DCore::QBuffer;
++
++ vbuffer->setData(vdata);
++ Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
++ vbufferBackend->setRenderer(test->renderer());
++ vbufferBackend->setManager(test->nodeManagers()->bufferManager());
++ simulateInitializationSync(vbuffer, vbufferBackend);
++
++ Qt3DCore::QGeometry *g = new Qt3DCore::QGeometry;
++ g->addAttribute(new Qt3DCore::QAttribute);
++
++ const QList<Qt3DCore::QAttribute *> attrs = g->attributes();
++ Qt3DCore::QAttribute *attr = attrs[0];
++ attr->setBuffer(vbuffer);
++ attr->setName(Qt3DCore::QAttribute::defaultPositionAttributeName());
++ attr->setVertexBaseType(Qt3DCore::QAttribute::Float);
++ attr->setVertexSize(3);
++ attr->setCount(6);
++ attr->setByteOffset(0);
++ attr->setByteStride(0);
++
++ Qt3DRender::QGeometryRenderer *gr = new Qt3DRender::QGeometryRenderer;
++ gr->setVertexCount(drawVertexCount);
++ gr->setGeometry(g);
++ entity->addComponent(gr);
++
++ Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
++ attr0Backend->setRenderer(test->renderer());
++ simulateInitializationSync(attrs[0], attr0Backend);
++
++ Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
++ gBackend->setRenderer(test->renderer());
++ simulateInitializationSync(g, gBackend);
++
++ Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
++ grBackend->setRenderer(test->renderer());
++ grBackend->setManager(test->nodeManagers()->geometryRendererManager());
++ simulateInitializationSync(gr, grBackend);
++
++ Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
++ entityBackend->setRenderer(test->renderer());
++ simulateInitializationSync(entity.data(), entityBackend);
++
++ test->registerTree(entity.data());
++
++ Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
++ calcBVolume.setFrontEndNodeManager(test.data());
++ calcBVolume.setManagers(test->nodeManagers());
++ calcBVolume.setRoot(test->sceneRoot());
++ calcBVolume.run();
++
++ Vector3D center = entityBackend->localBoundingVolume()->center();
++ float radius = entityBackend->localBoundingVolume()->radius();
++ qDebug() << radius << center;
++
++ QCOMPARE(radius, expectedRadius);
++ QCOMPARE(center.x(), expectedCenter.x());
++ QCOMPARE(center.y(), expectedCenter.y());
++ QCOMPARE(center.z(), expectedCenter.z());
++ }
++ };
++
++ QTEST_MAIN(tst_BoundingSphere)
++
++ #include "tst_boundingsphere.moc"