Revise buffer traversal in bounding volume calculation

Take the index attribute (and buffer) into account, when present.

Rely on QGeometryRenderer::vertexCount(), when set.

Initially done on dev as: 1d874d33da9174a82fccc266c66a22af006ac8ef

Task-number: QTBUG-65590
Change-Id: I98d1865e3581272471d6b93b9633da38dc77163d
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

1 files changed, 136 insertions, 1 deletions

diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index fcbfaf6ba..767df4604 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -65,6 +65,8 @@
 #include <Qt3DExtras/qcuboidmesh.h>
 #include <Qt3DExtras/qplanemesh.h>
 
+#include <qbackendnodetester.h>
+
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
@@ -100,6 +102,7 @@ public:
     Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const { return d_func()->m_renderer->frameGraphRoot(); }
     Qt3DRender::Render::RenderSettings *renderSettings() const { return d_func()->m_renderer->settings(); }
     Qt3DRender::Render::Entity *sceneRoot() const { return m_sceneRoot; }
+    Qt3DRender::Render::AbstractRenderer *renderer() const { return d_func()->m_renderer; }
 
 private:
     Render::Entity *m_sceneRoot;
@@ -153,7 +156,7 @@ void runRequiredJobs(Qt3DRender::TestAspect *test)
 
 } // anonymous
 
-class tst_BoundingSphere : public QObject
+class tst_BoundingSphere : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
 private:
@@ -194,6 +197,138 @@ private Q_SLOTS:
         QVERIFY(qAbs(boundingSphere->center().y() - sphereCenter.y()) < 0.000001f);
         QVERIFY(qAbs(boundingSphere->center().z() - sphereCenter.z()) < 0.000001f);
     }
+
+    void checkCustomGeometry_data()
+    {
+        QTest::addColumn<int>("drawVertexCount");
+        QTest::addColumn<int>("indexByteOffset");
+        QTest::addColumn<QVector3D>("expectedCenter");
+        QTest::addColumn<float>("expectedRadius");
+        QTest::newRow("all") << 0 << 0 << QVector3D(-0.488892f, 0.0192147f, -75.4804f) << 25.5442f;
+        QTest::newRow("first only") << 3 << 0 << QVector3D(0, 1, -100) << 1.0f;
+        QTest::newRow("second only") << 3 << int(3 * sizeof(ushort)) << QVector3D(0, -1, -50) << 1.0f;
+    }
+
+    void checkCustomGeometry()
+    {
+        QFETCH(int, drawVertexCount);
+        QFETCH(int, indexByteOffset);
+        QFETCH(QVector3D, expectedCenter);
+        QFETCH(float, expectedRadius);
+
+        // 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;
+        idata.resize(6 * sizeof(ushort));
+        ushort *ip = reinterpret_cast<ushort *>(idata.data());
+        *ip++ = 0;
+        *ip++ = 1;
+        *ip++ = 2;
+        *ip++ = 3;
+        *ip++ = 4;
+        *ip++ = 5;
+
+        QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity);
+        QScopedPointer<Qt3DRender::TestAspect> test(new Qt3DRender::TestAspect(entity.data()));
+        Qt3DRender::QBuffer *vbuffer = new Qt3DRender::QBuffer;
+        Qt3DRender::QBuffer *ibuffer = new Qt3DRender::QBuffer;
+
+        vbuffer->setData(vdata);
+        Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
+        vbufferBackend->setRenderer(test->renderer());
+        vbufferBackend->setManager(test->nodeManagers()->bufferManager());
+        simulateInitialization(vbuffer, vbufferBackend);
+
+        ibuffer->setData(idata);
+        Qt3DRender::Render::Buffer *ibufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(ibuffer->id());
+        ibufferBackend->setRenderer(test->renderer());
+        ibufferBackend->setManager(test->nodeManagers()->bufferManager());
+        simulateInitialization(ibuffer, ibufferBackend);
+
+        Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry;
+        for (int i = 0; i < 2; ++i)
+            g->addAttribute(new Qt3DRender::QAttribute);
+
+        const QVector<Qt3DRender::QAttribute *> attrs = g->attributes();
+        Qt3DRender::QAttribute *attr = attrs[0];
+        attr->setBuffer(vbuffer);
+        attr->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
+        attr->setVertexBaseType(Qt3DRender::QAttribute::Float);
+        attr->setVertexSize(3);
+        attr->setCount(6);
+        attr->setByteOffset(0);
+        attr->setByteStride(3 * sizeof(float));
+
+        attr = attrs[1];
+        attr->setBuffer(ibuffer);
+        attr->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
+        attr->setVertexBaseType(Qt3DRender::QAttribute::UnsignedShort);
+        attr->setVertexSize(1);
+        attr->setCount(6);
+        attr->setByteOffset(indexByteOffset);
+
+        Qt3DRender::QGeometryRenderer *gr = new Qt3DRender::QGeometryRenderer;
+        gr->setVertexCount(drawVertexCount); // when 0, indexAttribute->count() is used instead
+        gr->setGeometry(g);
+        entity->addComponent(gr);
+
+        Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
+        attr0Backend->setRenderer(test->renderer());
+        simulateInitialization(attrs[0], attr0Backend);
+        Qt3DRender::Render::Attribute *attr1Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[1]->id());
+        attr1Backend->setRenderer(test->renderer());
+        simulateInitialization(attrs[1], attr1Backend);
+
+        Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
+        gBackend->setRenderer(test->renderer());
+        simulateInitialization(g, gBackend);
+
+        Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
+        grBackend->setRenderer(test->renderer());
+        grBackend->setManager(test->nodeManagers()->geometryRendererManager());
+        simulateInitialization(gr, grBackend);
+
+        Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
+        entityBackend->setRenderer(test->renderer());
+        simulateInitialization(entity.data(), entityBackend);
+
+        Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
+        calcBVolume.setManagers(test->nodeManagers());
+        calcBVolume.setRoot(test->sceneRoot());
+        calcBVolume.run();
+
+        QVector3D center = entityBackend->localBoundingVolume()->center();
+        float radius = entityBackend->localBoundingVolume()->radius();
+        qDebug() << radius << center;
+
+        // truncate and compare integers only
+        QVERIFY(int(radius) == int(expectedRadius));
+        QVERIFY(int(center.x()) == int(expectedCenter.x()));
+        QVERIFY(int(center.y()) == int(expectedCenter.y()));
+        QVERIFY(int(center.z()) == int(expectedCenter.z()));
+    }
 };
 
 QTEST_MAIN(tst_BoundingSphere)