diff options
Diffstat (limited to 'tests/auto/render')
56 files changed, 3227 insertions, 289 deletions
diff --git a/tests/auto/render/boundingsphere/boundingsphere.pro b/tests/auto/render/boundingsphere/boundingsphere.pro new file mode 100644 index 000000000..cebba17e7 --- /dev/null +++ b/tests/auto/render/boundingsphere/boundingsphere.pro @@ -0,0 +1,17 @@ +TEMPLATE = app + +TARGET = tst_boundingsphere +QT += core-private 3dcore 3dcore-private 3drender 3drender-private 3dextras testlib + +CONFIG += testcase + +SOURCES += tst_boundingsphere.cpp + +include(../commons/commons.pri) +include(../../core/common/common.pri) +include(../qmlscenereader/qmlscenereader.pri) +# Extra dependencies to build test scenes needed by the tests +QT += quick 3dquick 3dquick-private 3dextras 3dquickextras + +RESOURCES += \ + boundingsphere.qrc diff --git a/tests/auto/render/boundingsphere/boundingsphere.qrc b/tests/auto/render/boundingsphere/boundingsphere.qrc new file mode 100644 index 000000000..5ea2cb958 --- /dev/null +++ b/tests/auto/render/boundingsphere/boundingsphere.qrc @@ -0,0 +1,6 @@ +<RCC> + <qresource prefix="/"> + <file>sphere.qml</file> + <file>cube.qml</file> + </qresource> +</RCC> diff --git a/tests/auto/render/boundingsphere/cube.qml b/tests/auto/render/boundingsphere/cube.qml new file mode 100644 index 000000000..11d6d4db1 --- /dev/null +++ b/tests/auto/render/boundingsphere/cube.qml @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** BSD License Usage +** Alternatively, you may use this file under the terms of the BSD license +** as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import Qt3D.Core 2.0 +import Qt3D.Render 2.0 +import Qt3D.Extras 2.0 + +Entity { + id: sceneRoot + + components: [ ] + + // Parent Entity + Entity { + + components: [ + CuboidMesh { id: testMesh; objectName: "testMesh" }, + PhongMaterial { id: material } + ] + } + +} diff --git a/tests/auto/render/boundingsphere/sphere.qml b/tests/auto/render/boundingsphere/sphere.qml new file mode 100644 index 000000000..1f0e2245a --- /dev/null +++ b/tests/auto/render/boundingsphere/sphere.qml @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** BSD License Usage +** Alternatively, you may use this file under the terms of the BSD license +** as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import Qt3D.Core 2.0 +import Qt3D.Render 2.0 +import Qt3D.Extras 2.0 + +Entity { + id: sceneRoot + + components: [ ] + + // Parent Entity + Entity { + + components: [ + SphereMesh { id: testMesh; objectName: "testMesh" }, + PhongMaterial { id: material } + ] + } + +} diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp new file mode 100644 index 000000000..fcbfaf6ba --- /dev/null +++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp @@ -0,0 +1,201 @@ +/**************************************************************************** +** +** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qmlscenereader.h" +#include "testpostmanarbiter.h" + +#include <QUrl> + +#include <QtTest/QTest> +#include <Qt3DCore/qentity.h> +#include <Qt3DCore/qtransform.h> +#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> +#include <Qt3DCore/private/qaspectjobmanager_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/updatemeshtrianglelistjob_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/calcgeometrytrianglevolumes_p.h> +#include <Qt3DRender/private/loadbufferjob_p.h> +#include <Qt3DRender/private/buffermanager_p.h> +#include <Qt3DRender/private/geometryrenderermanager_p.h> +#include <Qt3DRender/private/sphere_p.h> + +#include <Qt3DExtras/qspheremesh.h> +#include <Qt3DExtras/qcylindermesh.h> +#include <Qt3DExtras/qtorusmesh.h> +#include <Qt3DExtras/qcuboidmesh.h> +#include <Qt3DExtras/qplanemesh.h> + +QT_BEGIN_NAMESPACE + +namespace Qt3DRender { + +class TestAspect : public Qt3DRender::QRenderAspect +{ +public: + TestAspect(Qt3DCore::QNode *root) + : Qt3DRender::QRenderAspect(Qt3DRender::QRenderAspect::Synchronous) + , m_sceneRoot(nullptr) + { + QRenderAspect::onRegistered(); + + const Qt3DCore::QNodeCreatedChangeGenerator generator(root); + const QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = generator.creationChanges(); + + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), creationChanges); + + Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId()); + Q_ASSERT(rootEntity); + m_sceneRoot = rootEntity; + } + + ~TestAspect() + { + QRenderAspect::onUnregistered(); + } + + void onRegistered() { QRenderAspect::onRegistered(); } + void onUnregistered() { 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(); } + Qt3DRender::Render::Entity *sceneRoot() const { return m_sceneRoot; } + +private: + Render::Entity *m_sceneRoot; +}; + +} // namespace Qt3DRender + +QT_END_NAMESPACE + +namespace { + +void runRequiredJobs(Qt3DRender::TestAspect *test) +{ + Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; + updateWorldTransform.setRoot(test->sceneRoot()); + updateWorldTransform.run(); + + // For each buffer + QVector<Qt3DRender::Render::HBuffer> bufferHandles = test->nodeManagers()->bufferManager()->activeHandles(); + for (auto bufferHandle : bufferHandles) { + Qt3DRender::Render::LoadBufferJob loadBuffer(bufferHandle); + loadBuffer.setNodeManager(test->nodeManagers()); + loadBuffer.run(); + } + + Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume; + calcBVolume.setManagers(test->nodeManagers()); + calcBVolume.setRoot(test->sceneRoot()); + calcBVolume.run(); + + Qt3DRender::Render::UpdateWorldBoundingVolumeJob updateWorldBVolume; + updateWorldBVolume.setManager(test->nodeManagers()->renderNodesManager()); + updateWorldBVolume.run(); + + Qt3DRender::Render::ExpandBoundingVolumeJob expandBVolume; + expandBVolume.setRoot(test->sceneRoot()); + expandBVolume.run(); + + Qt3DRender::Render::UpdateMeshTriangleListJob updateTriangleList; + updateTriangleList.setManagers(test->nodeManagers()); + updateTriangleList.run(); + + // For each geometry id + QVector<Qt3DRender::Render::HGeometryRenderer> geometryRenderHandles = test->nodeManagers()->geometryRendererManager()->activeHandles(); + for (auto geometryRenderHandle : geometryRenderHandles) { + Qt3DCore::QNodeId geometryRendererId = test->nodeManagers()->geometryRendererManager()->data(geometryRenderHandle)->peerId(); + Qt3DRender::Render::CalcGeometryTriangleVolumes calcGeometryTriangles(geometryRendererId, test->nodeManagers()); + calcGeometryTriangles.run(); + } +} + +} // anonymous + +class tst_BoundingSphere : public QObject +{ + Q_OBJECT +private: + +private Q_SLOTS: + 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.0928356f, -0.212021f, -0.0467958f) << 1.07583f; // weird! + } + + 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 + 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(qAbs(boundingSphere->center().x() - sphereCenter.x()) < 0.000001f); // qFuzzyCompare hates 0s + QVERIFY(qAbs(boundingSphere->center().y() - sphereCenter.y()) < 0.000001f); + QVERIFY(qAbs(boundingSphere->center().z() - sphereCenter.z()) < 0.000001f); + } +}; + +QTEST_MAIN(tst_BoundingSphere) + +#include "tst_boundingsphere.moc" diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp index da5f74dd6..8049aaf37 100644 --- a/tests/auto/render/buffer/tst_buffer.cpp +++ b/tests/auto/render/buffer/tst_buffer.cpp @@ -33,7 +33,6 @@ #include <Qt3DRender/private/buffermanager_p.h> #include <Qt3DCore/qpropertyupdatedchange.h> #include <Qt3DCore/private/qbackendnode_p.h> -#include <Qt3DCore/private/qpropertyupdatedchangebase_p.h> #include "testpostmanarbiter.h" #include "testrenderer.h" @@ -51,7 +50,7 @@ public: bool operator ==(const Qt3DRender::QBufferDataGenerator &other) const Q_DECL_FINAL { - const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other); + const TestFunctor *otherFunctor = Qt3DRender::functor_cast<TestFunctor>(&other); if (otherFunctor != nullptr) return otherFunctor->m_size == m_size; return false; @@ -90,6 +89,8 @@ private Q_SLOTS: QCOMPARE(renderBuffer.data(), buffer.data()); QCOMPARE(renderBuffer.dataGenerator(), buffer.dataGenerator()); QVERIFY(*renderBuffer.dataGenerator() == *buffer.dataGenerator()); + QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1); + QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1); } void checkInitialAndCleanedUpState() @@ -196,7 +197,10 @@ private Q_SLOTS: // THEN QCOMPARE(renderBuffer.data(), QByteArrayLiteral("LS9")); QVERIFY(renderBuffer.isDirty()); + QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1); + QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1); + renderBuffer.pendingBufferUpdates().clear(); renderBuffer.unsetDirty(); QVERIFY(!renderBuffer.isDirty()); @@ -234,9 +238,11 @@ private Q_SLOTS: Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "data"); QCOMPARE(change->value().toByteArray(), QByteArrayLiteral("454")); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); + QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1); + QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1); arbiter.events.clear(); + renderBuffer.pendingBufferUpdates().clear(); // WHEN updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); @@ -249,6 +255,7 @@ private Q_SLOTS: // THEN QVERIFY(!renderBuffer.pendingBufferUpdates().empty()); + QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, 2); QVERIFY(renderBuffer.isDirty()); renderBuffer.unsetDirty(); diff --git a/tests/auto/render/commons/testrenderer.cpp b/tests/auto/render/commons/testrenderer.cpp index 87e60a263..5304ff142 100644 --- a/tests/auto/render/commons/testrenderer.cpp +++ b/tests/auto/render/commons/testrenderer.cpp @@ -32,6 +32,7 @@ QT_BEGIN_NAMESPACE TestRenderer::TestRenderer() : m_changes(0) + , m_managers(nullptr) { } @@ -76,4 +77,9 @@ QSurfaceFormat TestRenderer::format() return QSurfaceFormat(); } +QOpenGLContext *TestRenderer::shareContext() const +{ + return nullptr; +} + QT_END_NAMESPACE diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h index 2e572582e..031ca214b 100644 --- a/tests/auto/render/commons/testrenderer.h +++ b/tests/auto/render/commons/testrenderer.h @@ -43,10 +43,10 @@ public: API api() const Q_DECL_OVERRIDE { return AbstractRenderer::OpenGL; } qint64 time() const Q_DECL_OVERRIDE { return 0; } void setTime(qint64 time) Q_DECL_OVERRIDE { Q_UNUSED(time); } - void setNodeManagers(Qt3DRender::Render::NodeManagers *managers) Q_DECL_OVERRIDE { Q_UNUSED(managers); } + void setNodeManagers(Qt3DRender::Render::NodeManagers *m) Q_DECL_OVERRIDE { m_managers = m; } void setServices(Qt3DCore::QServiceLocator *services) Q_DECL_OVERRIDE { Q_UNUSED(services); } void setSurfaceExposed(bool exposed) Q_DECL_OVERRIDE { Q_UNUSED(exposed); } - Qt3DRender::Render::NodeManagers *nodeManagers() const Q_DECL_OVERRIDE { return nullptr; } + Qt3DRender::Render::NodeManagers *nodeManagers() const Q_DECL_OVERRIDE { return m_managers; } Qt3DCore::QServiceLocator *services() const Q_DECL_OVERRIDE { return nullptr; } void initialize() Q_DECL_OVERRIDE {} void shutdown() Q_DECL_OVERRIDE {} @@ -60,6 +60,7 @@ public: QVector<Qt3DCore::QAspectJobPtr> renderBinJobs() Q_DECL_OVERRIDE { return QVector<Qt3DCore::QAspectJobPtr>(); } Qt3DCore::QAspectJobPtr pickBoundingVolumeJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); } Qt3DCore::QAspectJobPtr syncTextureLoadingJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); } + Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() Q_DECL_OVERRIDE { return Qt3DCore::QAspectJobPtr(); } void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Qt3DRender::Render::Entity *root) Q_DECL_OVERRIDE { Q_UNUSED(factory); Q_UNUSED(root); } Qt3DRender::Render::Entity *sceneRoot() const Q_DECL_OVERRIDE { return nullptr; } Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const Q_DECL_OVERRIDE { return nullptr; } @@ -74,12 +75,14 @@ public: void resetDirty(); QVariant executeCommand(const QStringList &args) Q_DECL_OVERRIDE; + QOpenGLContext *shareContext() const Q_DECL_OVERRIDE; void setOffscreenSurfaceHelper(Qt3DRender::Render::OffscreenSurfaceHelper *helper) Q_DECL_OVERRIDE; QSurfaceFormat format() Q_DECL_OVERRIDE; protected: Qt3DRender::Render::AbstractRenderer::BackendNodeDirtySet m_changes; + Qt3DRender::Render::NodeManagers *m_managers; }; QT_END_NAMESPACE diff --git a/tests/auto/render/coordinatereader/coordinatereader.pro b/tests/auto/render/coordinatereader/coordinatereader.pro new file mode 100644 index 000000000..036898c2b --- /dev/null +++ b/tests/auto/render/coordinatereader/coordinatereader.pro @@ -0,0 +1,12 @@ +TEMPLATE = app + +TARGET = coordinatereader + +QT += 3dcore 3dcore-private 3drender 3drender-private testlib + +CONFIG += testcase + +SOURCES += tst_coordinatereader.cpp + +include(../../core/common/common.pri) +include(../commons/commons.pri) diff --git a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp new file mode 100644 index 000000000..7dfe3ceba --- /dev/null +++ b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp @@ -0,0 +1,491 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QTest> +#include <qbackendnodetester.h> +#include <Qt3DRender/qgeometryrenderer.h> +#include <Qt3DRender/qbuffer.h> +#include <private/trianglesvisitor_p.h> +#include <private/nodemanagers_p.h> +#include <private/managers_p.h> +#include <private/geometryrenderer_p.h> +#include <private/geometryrenderermanager_p.h> +#include <private/buffermanager_p.h> +#include "testrenderer.h" + +using namespace Qt3DRender::Render; + +class TestReader : public CoordinateReader +{ +public: + TestReader(NodeManagers *manager) + : CoordinateReader(manager) + { + + } + NodeManagers *manager() const + { + return m_manager; + } + + Attribute *attribute() const + { + return m_attribute; + } + + Buffer *buffer() const + { + return m_buffer; + } + + BufferInfo bufferInfo() const + { + return m_bufferInfo; + } + bool verifyCoordinate(uint index, QVector4D value) + { + return qFuzzyCompare(getCoordinate(index), value); + } +}; + +class tst_CoordinateReader : public Qt3DCore::QBackendNodeTester +{ + Q_OBJECT + +private Q_SLOTS: + + void checkInitialize() + { + // WHEN + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + TestReader reader(nodeManagers.data()); + + // THEN + QCOMPARE(reader.manager(), nodeManagers.data()); + } + + void checkSetEmptyGeometry() + { + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer( + new Qt3DRender::QGeometryRenderer()); + TestReader reader(nodeManagers.data()); + TestRenderer renderer; + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer.data(), backendRenderer); + + // WHEN + bool ret = reader.setGeometry(backendRenderer, QString("")); + + // THEN + QCOMPARE(ret, false); + QCOMPARE(reader.attribute(), nullptr); + QCOMPARE(reader.buffer(), nullptr); + } + + void checkSetGeometry() + { + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry(); + QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer( + new Qt3DRender::QGeometryRenderer()); + QScopedPointer<Qt3DRender::QAttribute> positionAttribute(new Qt3DRender::QAttribute()); + QScopedPointer<Qt3DRender::QBuffer> dataBuffer(new Qt3DRender::QBuffer()); + TestReader reader(nodeManagers.data()); + TestRenderer renderer; + + QByteArray data; + data.resize(sizeof(float) * 3 * 3 * 2); + float *dataPtr = reinterpret_cast<float *>(data.data()); + dataPtr[0] = 0; + dataPtr[1] = 0; + dataPtr[2] = 1.0f; + dataPtr[3] = 1.0f; + dataPtr[4] = 0; + dataPtr[5] = 0; + dataPtr[6] = 0; + dataPtr[7] = 1.0f; + dataPtr[8] = 0; + + dataPtr[9] = 0; + dataPtr[10] = 0; + dataPtr[11] = 1.0f; + dataPtr[12] = 1.0f; + dataPtr[13] = 0; + dataPtr[14] = 0; + dataPtr[15] = 0; + dataPtr[16] = 1.0f; + dataPtr[17] = 0; + dataBuffer->setData(data); + Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); + backendBuffer->setRenderer(&renderer); + backendBuffer->setManager(nodeManagers->bufferManager()); + simulateInitialization(dataBuffer.data(), backendBuffer); + + positionAttribute->setBuffer(dataBuffer.data()); + positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); + positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + positionAttribute->setVertexSize(3); + positionAttribute->setCount(6); + positionAttribute->setByteStride(3 * 4); + positionAttribute->setByteOffset(0); + positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(positionAttribute.data()); + + geometryRenderer->setGeometry(geometry); + geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles); + + Attribute *backendAttribute = nodeManagers->attributeManager() + ->getOrCreateResource(positionAttribute->id()); + backendAttribute->setRenderer(&renderer); + simulateInitialization(positionAttribute.data(), backendAttribute); + + Geometry *backendGeometry = nodeManagers->geometryManager() + ->getOrCreateResource(geometry->id()); + backendGeometry->setRenderer(&renderer); + simulateInitialization(geometry, backendGeometry); + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer.data(), backendRenderer); + + // WHEN + bool ret = reader.setGeometry(backendRenderer, + Qt3DRender::QAttribute::defaultPositionAttributeName()); + + // THEN + QCOMPARE(ret, true); + QCOMPARE(reader.attribute(), backendAttribute); + QCOMPARE(reader.buffer(), backendBuffer); + QCOMPARE(reader.bufferInfo().type, Qt3DRender::QAttribute::Float); + QCOMPARE(reader.bufferInfo().dataSize, 3u); + QCOMPARE(reader.bufferInfo().count, 6u); + QCOMPARE(reader.bufferInfo().byteStride, 12u); + QCOMPARE(reader.bufferInfo().byteOffset, 0u); + } + + void testReadCoordinate() + { + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry(); + QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer( + new Qt3DRender::QGeometryRenderer()); + QScopedPointer<Qt3DRender::QAttribute> positionAttribute(new Qt3DRender::QAttribute()); + QScopedPointer<Qt3DRender::QBuffer> dataBuffer(new Qt3DRender::QBuffer()); + TestReader reader(nodeManagers.data()); + TestRenderer renderer; + + QByteArray data; + data.resize(sizeof(float) * 3 * 3 * 2); + float *dataPtr = reinterpret_cast<float *>(data.data()); + dataPtr[0] = 0; + dataPtr[1] = 0; + dataPtr[2] = 1.0f; + dataPtr[3] = 1.0f; + dataPtr[4] = 0; + dataPtr[5] = 0; + dataPtr[6] = 0; + dataPtr[7] = 1.0f; + dataPtr[8] = 0; + + dataPtr[9] = 0; + dataPtr[10] = 0; + dataPtr[11] = 1.0f; + dataPtr[12] = 1.0f; + dataPtr[13] = 0; + dataPtr[14] = 0; + dataPtr[15] = 0; + dataPtr[16] = 1.0f; + dataPtr[17] = 0; + dataBuffer->setData(data); + Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); + backendBuffer->setRenderer(&renderer); + backendBuffer->setManager(nodeManagers->bufferManager()); + simulateInitialization(dataBuffer.data(), backendBuffer); + + positionAttribute->setBuffer(dataBuffer.data()); + positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); + positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + positionAttribute->setVertexSize(3); + positionAttribute->setCount(6); + positionAttribute->setByteStride(3 * 4); + positionAttribute->setByteOffset(0); + positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(positionAttribute.data()); + + geometryRenderer->setGeometry(geometry); + geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles); + + Attribute *backendAttribute = nodeManagers->attributeManager() + ->getOrCreateResource(positionAttribute->id()); + backendAttribute->setRenderer(&renderer); + simulateInitialization(positionAttribute.data(), backendAttribute); + + Geometry *backendGeometry = nodeManagers->geometryManager() + ->getOrCreateResource(geometry->id()); + backendGeometry->setRenderer(&renderer); + simulateInitialization(geometry, backendGeometry); + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer.data(), backendRenderer); + + // WHEN + bool ret = reader.setGeometry(backendRenderer, + Qt3DRender::QAttribute::defaultPositionAttributeName()); + + // THEN + QCOMPARE(ret, true); + + QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1))); + QVERIFY(reader.verifyCoordinate(1, QVector4D(1, 0, 0, 1))); + QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 1))); + QVERIFY(reader.verifyCoordinate(3, QVector4D(0, 0, 1, 1))); + QVERIFY(reader.verifyCoordinate(4, QVector4D(1, 0, 0, 1))); + QVERIFY(reader.verifyCoordinate(5, QVector4D(0, 1, 0, 1))); + } + + void testReadCoordinateVec4() + { + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry(); + QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer( + new Qt3DRender::QGeometryRenderer()); + QScopedPointer<Qt3DRender::QAttribute> positionAttribute(new Qt3DRender::QAttribute()); + QScopedPointer<Qt3DRender::QBuffer> dataBuffer(new Qt3DRender::QBuffer()); + TestReader reader(nodeManagers.data()); + TestRenderer renderer; + + QByteArray data; + data.resize(sizeof(float) * 4 * 3 * 2); + float *dataPtr = reinterpret_cast<float *>(data.data()); + dataPtr[0] = 0; + dataPtr[1] = 0; + dataPtr[2] = 1.0f; + dataPtr[3] = 1.0f; + + dataPtr[4] = 1.0f; + dataPtr[5] = 0; + dataPtr[6] = 0; + dataPtr[7] = 1.0f; + + dataPtr[8] = 0; + dataPtr[9] = 1.0f; + dataPtr[10] = 0; + dataPtr[11] = 0; + + dataPtr[12] = 0; + dataPtr[13] = 0; + dataPtr[14] = 1.0f; + dataPtr[15] = 0; + + dataPtr[16] = 1.0f; + dataPtr[17] = 0; + dataPtr[18] = 0; + dataPtr[19] = 0; + + dataPtr[20] = 0; + dataPtr[21] = 1.0f; + dataPtr[22] = 0; + dataPtr[23] = 1.0f; + + dataBuffer->setData(data); + Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); + backendBuffer->setRenderer(&renderer); + backendBuffer->setManager(nodeManagers->bufferManager()); + simulateInitialization(dataBuffer.data(), backendBuffer); + + positionAttribute->setBuffer(dataBuffer.data()); + positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); + positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + positionAttribute->setVertexSize(4); + positionAttribute->setCount(6); + positionAttribute->setByteStride(4 * 4); + positionAttribute->setByteOffset(0); + positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(positionAttribute.data()); + + geometryRenderer->setGeometry(geometry); + geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles); + + Attribute *backendAttribute = nodeManagers->attributeManager() + ->getOrCreateResource(positionAttribute->id()); + backendAttribute->setRenderer(&renderer); + simulateInitialization(positionAttribute.data(), backendAttribute); + + Geometry *backendGeometry = nodeManagers->geometryManager() + ->getOrCreateResource(geometry->id()); + backendGeometry->setRenderer(&renderer); + simulateInitialization(geometry, backendGeometry); + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer.data(), backendRenderer); + + // WHEN + bool ret = reader.setGeometry(backendRenderer, + Qt3DRender::QAttribute::defaultPositionAttributeName()); + + // THEN + QCOMPARE(ret, true); + + QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1))); + QVERIFY(reader.verifyCoordinate(1, QVector4D(1, 0, 0, 1))); + QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 0))); + QVERIFY(reader.verifyCoordinate(3, QVector4D(0, 0, 1, 0))); + QVERIFY(reader.verifyCoordinate(4, QVector4D(1, 0, 0, 0))); + QVERIFY(reader.verifyCoordinate(5, QVector4D(0, 1, 0, 1))); + } + + void testReadCoordinateFromAttribute() + { + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry(); + QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer( + new Qt3DRender::QGeometryRenderer()); + QScopedPointer<Qt3DRender::QAttribute> positionAttribute(new Qt3DRender::QAttribute()); + QScopedPointer<Qt3DRender::QAttribute> texcoordAttribute(new Qt3DRender::QAttribute()); + QScopedPointer<Qt3DRender::QBuffer> dataBuffer(new Qt3DRender::QBuffer()); + TestReader reader(nodeManagers.data()); + TestRenderer renderer; + + QByteArray data; + data.resize(sizeof(float) * 3 * 3 * 2); + float *dataPtr = reinterpret_cast<float *>(data.data()); + dataPtr[0] = 0; + dataPtr[1] = 0; + dataPtr[2] = 1.0f; + + dataPtr[3] = 1.0f; + dataPtr[4] = 0; + dataPtr[5] = 0; + + dataPtr[6] = 0; + dataPtr[7] = 1.0f; + dataPtr[8] = 0; + + dataPtr[9] = 0; + dataPtr[10] = 0; + dataPtr[11] = 1.0f; + + dataPtr[12] = 1.0f; + dataPtr[13] = 0; + dataPtr[14] = 0; + + dataPtr[15] = 0; + dataPtr[16] = 1.0f; + dataPtr[17] = 0; + + dataBuffer->setData(data); + Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); + backendBuffer->setRenderer(&renderer); + backendBuffer->setManager(nodeManagers->bufferManager()); + simulateInitialization(dataBuffer.data(), backendBuffer); + + positionAttribute->setBuffer(dataBuffer.data()); + positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); + positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + positionAttribute->setVertexSize(3); + positionAttribute->setCount(3); + positionAttribute->setByteStride(3 * 4 * 2); + positionAttribute->setByteOffset(0); + positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(positionAttribute.data()); + + texcoordAttribute->setBuffer(dataBuffer.data()); + texcoordAttribute->setName(Qt3DRender::QAttribute::defaultTextureCoordinateAttributeName()); + texcoordAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + texcoordAttribute->setVertexSize(3); + texcoordAttribute->setCount(6); + texcoordAttribute->setByteStride(3 * 4 * 2); + texcoordAttribute->setByteOffset(3 * 4); + texcoordAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(texcoordAttribute.data()); + + geometryRenderer->setGeometry(geometry); + geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles); + + Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource( + positionAttribute->id()); + backendAttribute->setRenderer(&renderer); + simulateInitialization(positionAttribute.data(), backendAttribute); + + Attribute *backendTexcoordAttribute = nodeManagers->attributeManager() + ->getOrCreateResource(texcoordAttribute->id()); + backendTexcoordAttribute->setRenderer(&renderer); + simulateInitialization(texcoordAttribute.data(), backendTexcoordAttribute); + + Geometry *backendGeometry = nodeManagers->geometryManager() + ->getOrCreateResource(geometry->id()); + backendGeometry->setRenderer(&renderer); + simulateInitialization(geometry, backendGeometry); + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer.data(), backendRenderer); + + // WHEN + bool ret = reader.setGeometry(backendRenderer, + Qt3DRender::QAttribute::defaultPositionAttributeName()); + + // THEN + QCOMPARE(ret, true); + + QVERIFY(reader.verifyCoordinate(0, QVector4D(0, 0, 1, 1))); + QVERIFY(reader.verifyCoordinate(1, QVector4D(0, 1, 0, 1))); + QVERIFY(reader.verifyCoordinate(2, QVector4D(1, 0, 0, 1))); + + // WHEN + ret = reader.setGeometry(backendRenderer, + Qt3DRender::QAttribute::defaultTextureCoordinateAttributeName()); + + // THEN + QCOMPARE(ret, true); + + QVERIFY(reader.verifyCoordinate(0, QVector4D(1, 0, 0, 1))); + QVERIFY(reader.verifyCoordinate(1, QVector4D(0, 0, 1, 1))); + QVERIFY(reader.verifyCoordinate(2, QVector4D(0, 1, 0, 1))); + } + +}; + +QTEST_MAIN(tst_CoordinateReader) + +#include "tst_coordinatereader.moc" diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp index 0bd3a6054..d1a222c92 100644 --- a/tests/auto/render/entity/tst_entity.cpp +++ b/tests/auto/render/entity/tst_entity.cpp @@ -38,6 +38,7 @@ #include <Qt3DCore/QComponentRemovedChange> #include <Qt3DCore/QTransform> +#include <Qt3DRender/QEnvironmentLight> #include <Qt3DRender/QMesh> #include <Qt3DRender/QMaterial> #include <Qt3DRender/QLayer> @@ -64,6 +65,7 @@ QNodeId computeJobUuid(Entity *entity) { return entity->componentUuid<ComputeCom QVector<QNodeId> layersUuid(Entity *entity) { return entity->componentsUuid<Layer>(); } QVector<QNodeId> shadersUuid(Entity *entity) { return entity->componentsUuid<ShaderData>(); } +QVector<QNodeId> environmentLightsUuid(Entity *entity) { return entity->componentsUuid<EnvironmentLight>(); } class tst_RenderEntity : public QObject { @@ -86,7 +88,8 @@ private slots: << new QObjectPicker << new QLayer << new QShaderData - << new QComputeCommand; + << new QComputeCommand + << new QEnvironmentLight; QTest::newRow("all components") << components; } @@ -112,6 +115,7 @@ private slots: QVERIFY(entity.componentUuid<ComputeCommand>().isNull()); QVERIFY(entity.componentsUuid<Layer>().isEmpty()); QVERIFY(entity.componentsUuid<ShaderData>().isEmpty()); + QVERIFY(entity.componentsUuid<EnvironmentLight>().isEmpty()); QVERIFY(!entity.isBoundingVolumeDirty()); QVERIFY(entity.childrenHandles().isEmpty()); @@ -139,6 +143,7 @@ private slots: QVERIFY(!entity.componentUuid<ComputeCommand>().isNull()); QVERIFY(!entity.componentsUuid<Layer>().isEmpty()); QVERIFY(!entity.componentsUuid<ShaderData>().isEmpty()); + QVERIFY(!entity.componentsUuid<EnvironmentLight>().isEmpty()); QVERIFY(entity.isBoundingVolumeDirty()); QVERIFY(!entity.childrenHandles().isEmpty()); QVERIFY(renderer.dirtyBits() != 0); @@ -157,6 +162,7 @@ private slots: QVERIFY(entity.componentUuid<QComputeCommand>().isNull()); QVERIFY(entity.componentsUuid<Layer>().isEmpty()); QVERIFY(entity.componentsUuid<ShaderData>().isEmpty()); + QVERIFY(entity.componentsUuid<EnvironmentLight>().isEmpty()); QVERIFY(!entity.isBoundingVolumeDirty()); QVERIFY(entity.childrenHandles().isEmpty()); containsAll = entity.containsComponentsOfType<Transform, CameraLens, Material, GeometryRenderer, ObjectPicker, ComputeCommand>(); @@ -236,6 +242,10 @@ private slots: components.clear(); components << new QShaderData << new QShaderData << new QShaderData; QTest::newRow("shader data") << components << reinterpret_cast<void*>(shadersUuid); + + components.clear(); + components << new QEnvironmentLight << new QEnvironmentLight << new QEnvironmentLight; + QTest::newRow("environmentLights") << components << reinterpret_cast<void*>(environmentLightsUuid); } void shouldHandleComponentsEvents() diff --git a/tests/auto/render/framegraphvisitor/framegraphvisitor.pro b/tests/auto/render/framegraphvisitor/framegraphvisitor.pro new file mode 100644 index 000000000..2c9a0028e --- /dev/null +++ b/tests/auto/render/framegraphvisitor/framegraphvisitor.pro @@ -0,0 +1,13 @@ +TEMPLATE = app + +TARGET = tst_framegraphvisitor + +QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib + +CONFIG += testcase + +SOURCES += tst_framegraphvisitor.cpp + +CONFIG += useCommonTestAspect + +include(../commons/commons.pri) diff --git a/tests/auto/render/framegraphvisitor/tst_framegraphvisitor.cpp b/tests/auto/render/framegraphvisitor/tst_framegraphvisitor.cpp new file mode 100644 index 000000000..5344d7eb3 --- /dev/null +++ b/tests/auto/render/framegraphvisitor/tst_framegraphvisitor.cpp @@ -0,0 +1,174 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include <QtTest/QTest> +#include <Qt3DCore/qentity.h> + +#include <Qt3DRender/private/nodemanagers_p.h> +#include <Qt3DRender/private/managers_p.h> +#include <Qt3DRender/private/entity_p.h> + +#include <Qt3DRender/private/framegraphnode_p.h> +#include <Qt3DRender/private/framegraphvisitor_p.h> + +#include <Qt3DRender/qtechniquefilter.h> +#include <Qt3DRender/qnodraw.h> +#include <Qt3DRender/qfrustumculling.h> +#include <Qt3DRender/qviewport.h> + +#include "testaspect.h" + +namespace { + + + +} // anonymous + +using FGIdType = QPair<Qt3DCore::QNodeId, Qt3DRender::Render::FrameGraphNode::FrameGraphNodeType>; +using BranchIdsAndTypes = QVector<FGIdType>; + +Q_DECLARE_METATYPE(QVector<BranchIdsAndTypes>) + +class tst_FrameGraphVisitor : public QObject +{ + Q_OBJECT +private Q_SLOTS: + + void visitFGTree_data() + { + QTest::addColumn<Qt3DCore::QEntity *>("rootEntity"); + QTest::addColumn<Qt3DRender::QFrameGraphNode *>("fgRoot"); + QTest::addColumn<QVector<BranchIdsAndTypes>>("fgNodeIdsPerBranch"); + + { + Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(); + Qt3DRender::QTechniqueFilter *techniqueFilter = new Qt3DRender::QTechniqueFilter(entity); + + QTest::newRow("singleNode") << entity + << static_cast<Qt3DRender::QFrameGraphNode *>(techniqueFilter) + << (QVector<BranchIdsAndTypes>() + << (BranchIdsAndTypes() << FGIdType(techniqueFilter->id(), Qt3DRender::Render::FrameGraphNode::TechniqueFilter)) + ); + } + + { + Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(); + Qt3DRender::QTechniqueFilter *techniqueFilter = new Qt3DRender::QTechniqueFilter(entity); + Qt3DRender::QFrustumCulling *frustumCulling = new Qt3DRender::QFrustumCulling(techniqueFilter); + Qt3DRender::QNoDraw *noDraw = new Qt3DRender::QNoDraw(frustumCulling); + + QTest::newRow("singleBranch") << entity + << static_cast<Qt3DRender::QFrameGraphNode *>(techniqueFilter) + << (QVector<BranchIdsAndTypes>() + << (BranchIdsAndTypes() + << FGIdType(noDraw->id(), Qt3DRender::Render::FrameGraphNode::NoDraw) + << FGIdType(frustumCulling->id(), Qt3DRender::Render::FrameGraphNode::FrustumCulling) + << FGIdType(techniqueFilter->id(), Qt3DRender::Render::FrameGraphNode::TechniqueFilter) + ) + ); + } + { + Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(); + Qt3DRender::QTechniqueFilter *techniqueFilter = new Qt3DRender::QTechniqueFilter(entity); + Qt3DRender::QFrustumCulling *frustumCulling = new Qt3DRender::QFrustumCulling(techniqueFilter); + Qt3DRender::QNoDraw *noDraw = new Qt3DRender::QNoDraw(frustumCulling); + Qt3DRender::QViewport *viewPort = new Qt3DRender::QViewport(frustumCulling); + + QTest::newRow("dualBranch") << entity + << static_cast<Qt3DRender::QFrameGraphNode *>(techniqueFilter) + << (QVector<BranchIdsAndTypes>() + << (BranchIdsAndTypes() + << FGIdType(noDraw->id(), Qt3DRender::Render::FrameGraphNode::NoDraw) + << FGIdType(frustumCulling->id(), Qt3DRender::Render::FrameGraphNode::FrustumCulling) + << FGIdType(techniqueFilter->id(), Qt3DRender::Render::FrameGraphNode::TechniqueFilter) + ) + << (BranchIdsAndTypes() + << FGIdType(viewPort->id(), Qt3DRender::Render::FrameGraphNode::Viewport) + << FGIdType(frustumCulling->id(), Qt3DRender::Render::FrameGraphNode::FrustumCulling) + << FGIdType(techniqueFilter->id(), Qt3DRender::Render::FrameGraphNode::TechniqueFilter) + ) + ); + } + + } + + void visitFGTree() + { + // GIVEN + QFETCH(Qt3DCore::QEntity *, rootEntity); + QFETCH(Qt3DRender::QFrameGraphNode *, fgRoot); + QFETCH(QVector<BranchIdsAndTypes>, fgNodeIdsPerBranch); + QScopedPointer<Qt3DRender::TestAspect> aspect(new Qt3DRender::TestAspect(rootEntity)); + + // THEN + Qt3DRender::Render::FrameGraphManager *fgManager = aspect->nodeManagers()->frameGraphManager(); + Qt3DRender::Render::FrameGraphNode *backendFGRoot = fgManager->lookupNode(fgRoot->id()); + QVERIFY(backendFGRoot != nullptr); + + + // WHEN + Qt3DRender::Render::FrameGraphVisitor visitor(fgManager); + const QVector<Qt3DRender::Render::FrameGraphNode *> fgNodes = visitor.traverse(backendFGRoot); + + // THEN + QCOMPARE(fgNodeIdsPerBranch.size(), fgNodes.size()); + + for (int i = 0; i < fgNodeIdsPerBranch.size(); ++i) { + const BranchIdsAndTypes brandIdsAndTypes = fgNodeIdsPerBranch.at(i); + + Qt3DRender::Render::FrameGraphNode *fgNode = fgNodes.at(i); + for (int j = 0; j < brandIdsAndTypes.size(); ++j) { + const FGIdType idAndType = brandIdsAndTypes.at(j); + QVERIFY(fgNode != nullptr); + QCOMPARE(fgNode->peerId(), idAndType.first); + QCOMPARE(fgNode->nodeType(), idAndType.second); + fgNode = fgNode->parent(); + } + + QVERIFY(fgNode == nullptr); + } + + delete rootEntity; + } +}; + +QTEST_MAIN(tst_FrameGraphVisitor) + +#include "tst_framegraphvisitor.moc" diff --git a/tests/auto/render/geometryloaders/tst_geometryloaders.cpp b/tests/auto/render/geometryloaders/tst_geometryloaders.cpp index 15600dc75..7b9f09d23 100644 --- a/tests/auto/render/geometryloaders/tst_geometryloaders.cpp +++ b/tests/auto/render/geometryloaders/tst_geometryloaders.cpp @@ -102,6 +102,9 @@ void tst_geometryloaders::testOBJLoader() case QAttribute::VertexAttribute: QCOMPARE(attr->count(), 24u); break; + default: + Q_UNREACHABLE(); + break; } } @@ -141,6 +144,9 @@ void tst_geometryloaders::testPLYLoader() case QAttribute::VertexAttribute: QCOMPARE(attr->count(), 24u); break; + default: + Q_UNREACHABLE(); + break; } } @@ -212,6 +218,9 @@ void tst_geometryloaders::testGLTFLoader() case QAttribute::VertexAttribute: QCOMPARE(attr->count(), 24u); break; + default: + Q_UNREACHABLE(); + break; } } diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp index 7cf70c03c..70fe957c5 100644 --- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp +++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp @@ -51,7 +51,7 @@ public: bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_FINAL { - const TestFactory *otherFactory = functor_cast<TestFactory>(&other); + const TestFactory *otherFactory = Qt3DRender::functor_cast<TestFactory>(&other); if (otherFactory != nullptr) return otherFactory->m_size == m_size; return false; diff --git a/tests/auto/render/gltfplugins/tst_gltfplugins.cpp b/tests/auto/render/gltfplugins/tst_gltfplugins.cpp index a800fc1fa..e5a0eef21 100644 --- a/tests/auto/render/gltfplugins/tst_gltfplugins.cpp +++ b/tests/auto/render/gltfplugins/tst_gltfplugins.cpp @@ -139,8 +139,10 @@ private: Qt3DRender::QEffect *createOnTopEffect(); QTemporaryDir *m_exportDir; +#ifdef VISUAL_CHECK Qt3DExtras::Qt3DWindow *m_view1; Qt3DExtras::Qt3DWindow *m_view2; +#endif Qt3DCore::QEntity *m_sceneRoot1; Qt3DCore::QEntity *m_sceneRoot2; QHash<QString, Qt3DCore::QEntity *> m_entityMap; @@ -781,7 +783,7 @@ void tst_gltfPlugins::compareComponents(Qt3DCore::QComponent *c1, Qt3DCore::QCom auto property = c1->metaObject()->property(i); auto v1 = c1->property(property.name()); auto v2 = c2->property(property.name()); - if (v1.type() == QMetaType::Bool) { + if (v1.type() == QVariant::Bool) { QCOMPARE(v1.toBool(), v2.toBool()); } else if (v1.type() == QVariant::Color) { QCOMPARE(v1.value<QColor>(), v2.value<QColor>()); diff --git a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp index 9bc234c50..473e43d09 100644 --- a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp +++ b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp @@ -124,7 +124,7 @@ class tst_GraphicsHelperGL2 : public QObject Q_OBJECT private Q_SLOTS: - void initTestCase() + void init() { m_window.reset(new QWindow); m_window->setSurfaceType(QWindow::OpenGLSurface); @@ -160,7 +160,7 @@ private Q_SLOTS: } } - void cleanupTestCase() + void cleanup() { m_glContext.doneCurrent(); } @@ -1302,7 +1302,7 @@ private Q_SLOTS: // WHEN m_func->glUseProgram(shaderProgram.programId()); - GLfloat values[16] = { 454.0f, 350.0f, 883.0f, 355.0f, 1340.0f, 1584.0f, 1200.0f, 427.0f, 396.0f, 1603.0f, 55.0f, 5.7, 383.0f, 6.2f, 5.3f, 327.0f }; + GLfloat values[16] = { 454.0f, 350.0f, 883.0f, 355.0f, 1340.0f, 1584.0f, 1200.0f, 427.0f, 396.0f, 1603.0f, 55.0f, 5.7f, 383.0f, 6.2f, 5.3f, 327.0f }; const GLint location = shaderProgram.uniformLocation("m4"); m_glHelper.glUniformMatrix4fv(location, 1, values); diff --git a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp index fb0265427..b66192835 100644 --- a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp +++ b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp @@ -177,7 +177,7 @@ class tst_GraphicsHelperGL3_2 : public QObject Q_OBJECT private Q_SLOTS: - void initTestCase() + void init() { m_window.reset(new QWindow); m_window->setSurfaceType(QWindow::OpenGLSurface); @@ -209,7 +209,7 @@ private Q_SLOTS: } } - void cleanupTestCase() + void cleanup() { m_glContext.doneCurrent(); } @@ -1867,6 +1867,11 @@ private Q_SLOTS: if (!m_initializationSuccessful) QSKIP("Initialization failed, OpenGL 3.2 Core functions not supported"); + GLint maxSamples; + m_func->glGetIntegerv(GL_MAX_SAMPLES, &maxSamples); + if (maxSamples < 1) + QSKIP("This test requires an implementation that supports multisampled textures"); + // GIVEN GLuint fbos[2]; GLuint fboTextures[2]; @@ -1875,7 +1880,7 @@ private Q_SLOTS: m_func->glGenTextures(2, fboTextures); m_func->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, fboTextures[0]); - m_func->glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 10, 10, true); + m_func->glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxSamples, GL_RGBA8, 10, 10, true); m_func->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); m_func->glBindTexture(GL_TEXTURE_2D, fboTextures[1]); diff --git a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp index 293750dbf..b7cc1cdac 100644 --- a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp +++ b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp @@ -176,7 +176,7 @@ class tst_GraphicsHelperGL3_3 : public QObject Q_OBJECT private Q_SLOTS: - void initTestCase() + void init() { m_window.reset(new QWindow); m_window->setSurfaceType(QWindow::OpenGLSurface); @@ -209,7 +209,7 @@ private Q_SLOTS: } } - void cleanupTestCase() + void cleanup() { m_glContext.doneCurrent(); } @@ -1967,6 +1967,11 @@ private Q_SLOTS: if (!m_initializationSuccessful) QSKIP("Initialization failed, OpenGL 3.3 Core functions not supported"); + GLint maxSamples; + m_func->glGetIntegerv(GL_MAX_SAMPLES, &maxSamples); + if (maxSamples < 1) + QSKIP("This test requires an implementation that supports multisampled textures"); + // GIVEN GLuint fbos[2]; GLuint fboTextures[2]; @@ -1975,7 +1980,7 @@ private Q_SLOTS: m_func->glGenTextures(2, fboTextures); m_func->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, fboTextures[0]); - m_func->glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 10, 10, true); + m_func->glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, maxSamples, GL_RGBA8, 10, 10, true); m_func->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); m_func->glBindTexture(GL_TEXTURE_2D, fboTextures[1]); @@ -1986,13 +1991,13 @@ private Q_SLOTS: m_func->glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, fboTextures[1], 0); GLenum status = m_func->glCheckFramebufferStatus(GL_FRAMEBUFFER); - QVERIFY(status == GL_FRAMEBUFFER_COMPLETE); + QCOMPARE(status, GLenum(GL_FRAMEBUFFER_COMPLETE)); m_func->glBindFramebuffer(GL_FRAMEBUFFER, fbos[0]); m_func->glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, fboTextures[0], 0); status = m_func->glCheckFramebufferStatus(GL_FRAMEBUFFER); - QVERIFY(status == GL_FRAMEBUFFER_COMPLETE); + QCOMPARE(status, GLenum(GL_FRAMEBUFFER_COMPLETE)); m_func->glEnable(GL_MULTISAMPLE); m_func->glClearColor(0.2f, 0.2f, 0.2f, 0.2f); diff --git a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp index c6a306910..0ee14841c 100644 --- a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp +++ b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp @@ -201,7 +201,7 @@ class tst_GraphicsHelperGL4 : public QObject { Q_OBJECT private Q_SLOTS: - void initTestCase() + void init() { m_window.reset(new QWindow); m_window->setSurfaceType(QWindow::OpenGLSurface); @@ -234,7 +234,7 @@ private Q_SLOTS: } } - void cleanupTestCase() + void cleanup() { m_glContext.doneCurrent(); } diff --git a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp index ab0e8c4b8..148c54e58 100644 --- a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp +++ b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp @@ -29,7 +29,7 @@ #include <QtTest/QTest> #include <qbackendnodetester.h> #include <Qt3DRender/QLevelOfDetail> -#include <Qt3DRender/QBoundingSphere> +#include <Qt3DRender/QLevelOfDetailBoundingSphere> #include <Qt3DRender/private/levelofdetail_p.h> #include <Qt3DRender/private/qlevelofdetail_p.h> #include <Qt3DCore/qpropertyupdatedchange.h> @@ -57,8 +57,8 @@ private Q_SLOTS: QCOMPARE(renderLod.currentIndex(), lod.currentIndex()); QCOMPARE(renderLod.thresholdType(), lod.thresholdType()); QCOMPARE(renderLod.thresholds(), lod.thresholds()); - QCOMPARE(renderLod.center(), lod.volumeOverride()->center()); - QCOMPARE(renderLod.radius(), lod.volumeOverride()->radius()); + QCOMPARE(renderLod.center(), lod.volumeOverride().center()); + QCOMPARE(renderLod.radius(), lod.volumeOverride().radius()); } void checkInitialAndCleanedUpState() @@ -70,7 +70,7 @@ private Q_SLOTS: // THEN QCOMPARE(renderLod.camera(), Qt3DCore::QNodeId{}); QCOMPARE(renderLod.currentIndex(), 0); - QCOMPARE(renderLod.thresholdType(), Qt3DRender::QLevelOfDetail::DistanceToCamera); + QCOMPARE(renderLod.thresholdType(), Qt3DRender::QLevelOfDetail::DistanceToCameraThreshold); QVERIFY(renderLod.thresholds().empty()); QCOMPARE(renderLod.radius(), 1.f); QCOMPARE(renderLod.center(), QVector3D{}); @@ -78,7 +78,7 @@ private Q_SLOTS: // GIVEN Qt3DRender::QLevelOfDetail lod; - lod.setThresholdType(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize); + lod.setThresholdType(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold); // WHEN renderLod.setRenderer(&renderer); @@ -96,18 +96,18 @@ private Q_SLOTS: renderLod.setRenderer(&renderer); // THEN - QVERIFY(renderLod.thresholdType() != Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize); + QVERIFY(renderLod.thresholdType() != Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold); QVERIFY(renderLod.camera().isNull()); { // WHEN Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize)); + updateChange->setValue(static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold)); updateChange->setPropertyName("thresholdType"); renderLod.sceneChangeEvent(updateChange); // THEN - QCOMPARE(renderLod.thresholdType(), Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize); + QCOMPARE(renderLod.thresholdType(), Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold); QVERIFY(renderer.dirtyBits() != 0); } @@ -129,8 +129,9 @@ private Q_SLOTS: { // WHEN Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(QVector3D(1., 2., 3.)); - updateChange->setPropertyName("center"); + Qt3DRender::QLevelOfDetailBoundingSphere sphere(QVector3D(1.0f, 2.0f, 3.0f), 1.0f); + updateChange->setValue(QVariant::fromValue(sphere)); + updateChange->setPropertyName("volumeOverride"); renderLod.sceneChangeEvent(updateChange); // THEN diff --git a/tests/auto/render/loadscenejob/tst_loadscenejob.cpp b/tests/auto/render/loadscenejob/tst_loadscenejob.cpp index 08d1caace..e2e3997af 100644 --- a/tests/auto/render/loadscenejob/tst_loadscenejob.cpp +++ b/tests/auto/render/loadscenejob/tst_loadscenejob.cpp @@ -50,8 +50,14 @@ public: m_source = source; } - bool isFileTypeSupported(const QUrl &) const Q_DECL_OVERRIDE + void setData(const QByteArray& data, const QString &basePath) Q_DECL_OVERRIDE { + + } + + bool areFileTypesSupported(const QStringList &extensions) const + { + Q_UNUSED(extensions); return m_supportsFormat; } @@ -99,7 +105,7 @@ private Q_SLOTS: void checkInitialize() { // GIVEN - const QUrl url(QStringLiteral("URL")); + const QUrl url(QStringLiteral("file:///URL")); const Qt3DCore::QNodeId sceneId = Qt3DCore::QNodeId::createId(); Qt3DRender::Render::NodeManagers nodeManagers; TestSceneImporter fakeImporter(true, true); @@ -120,8 +126,10 @@ private Q_SLOTS: void checkRunValidSourceSupportedFormat() { + QSKIP("Can't test successful loading"); + // GIVEN - const QUrl url(QStringLiteral("URL")); + const QUrl url(QStringLiteral("file:///URL")); TestArbiter arbiter; Qt3DRender::Render::NodeManagers nodeManagers; TestSceneImporter fakeImporter(true, false); @@ -202,8 +210,11 @@ private Q_SLOTS: void checkRunValidSourceUnsupportedFormat() { + // no data is loaded so... + QSKIP("Can't differentiate between no data and unsupported data"); + // GIVEN - const QUrl url(QStringLiteral("URL")); + const QUrl url(QStringLiteral("file:///URL")); TestArbiter arbiter; Qt3DRender::Render::NodeManagers nodeManagers; TestSceneImporter fakeImporter(false, false); @@ -241,7 +252,7 @@ private Q_SLOTS: void checkRunErrorAtLoading() { // GIVEN - const QUrl url(QStringLiteral("URL")); + const QUrl url(QStringLiteral("file:///URL")); TestArbiter arbiter; Qt3DRender::Render::NodeManagers nodeManagers; TestSceneImporter fakeImporter(true, true); @@ -259,7 +270,7 @@ private Q_SLOTS: loadSceneJob.run(); // THEN - QCOMPARE(arbiter.events.count(), 4); + QCOMPARE(arbiter.events.count(), 3); auto change = arbiter.events.at(0).staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->subjectId(), scene->peerId()); QCOMPARE(change->propertyName(), "status"); @@ -267,16 +278,11 @@ private Q_SLOTS: change = arbiter.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->subjectId(), scene->peerId()); - QCOMPARE(change->propertyName(), "status"); - QCOMPARE(change->value().value<Qt3DRender::QSceneLoader::Status>(), Qt3DRender::QSceneLoader::Loading); - - change = arbiter.events.at(2).staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->subjectId(), scene->peerId()); QCOMPARE(change->propertyName(), "scene"); QVERIFY(change->value().value<Qt3DCore::QEntity *>() == nullptr); delete change->value().value<Qt3DCore::QEntity *>(); - change = arbiter.events.at(3).staticCast<Qt3DCore::QPropertyUpdatedChange>(); + change = arbiter.events.at(2).staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->subjectId(), scene->peerId()); QCOMPARE(change->propertyName(), "status"); QCOMPARE(change->value().value<Qt3DRender::QSceneLoader::Status>(), Qt3DRender::QSceneLoader::Error); diff --git a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp index d4f54f3af..f0d4931d9 100644 --- a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp +++ b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp @@ -50,14 +50,14 @@ private Q_SLOTS: QCOMPARE(backendMemoryBarrier.nodeType(), Qt3DRender::Render::FrameGraphNode::MemoryBarrier); QCOMPARE(backendMemoryBarrier.isEnabled(), false); QVERIFY(backendMemoryBarrier.peerId().isNull()); - QCOMPARE(backendMemoryBarrier.barrierTypes(), Qt3DRender::QMemoryBarrier::None); + QCOMPARE(backendMemoryBarrier.waitOperations(), Qt3DRender::QMemoryBarrier::None); } void checkInitializeFromPeer() { // GIVEN Qt3DRender::QMemoryBarrier memoryBarrier; - memoryBarrier.setBarrierTypes(Qt3DRender::QMemoryBarrier::VertexAttributeArrayBarrier); + memoryBarrier.setWaitOperations(Qt3DRender::QMemoryBarrier::VertexAttributeArray); { // WHEN @@ -67,7 +67,7 @@ private Q_SLOTS: // THEN QCOMPARE(backendMemoryBarrier.isEnabled(), true); QCOMPARE(backendMemoryBarrier.peerId(), memoryBarrier.id()); - QCOMPARE(backendMemoryBarrier.barrierTypes(), Qt3DRender::QMemoryBarrier::VertexAttributeArrayBarrier); + QCOMPARE(backendMemoryBarrier.waitOperations(), Qt3DRender::QMemoryBarrier::VertexAttributeArray); } { // WHEN @@ -101,14 +101,14 @@ private Q_SLOTS: } { // WHEN - const Qt3DRender::QMemoryBarrier::BarrierTypes newValue(Qt3DRender::QMemoryBarrier::AtomicCounterBarrier|Qt3DRender::QMemoryBarrier::ElementArrayBarrier); + const Qt3DRender::QMemoryBarrier::Operations newValue(Qt3DRender::QMemoryBarrier::AtomicCounter|Qt3DRender::QMemoryBarrier::ElementArray); const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("barrierTypes"); + change->setPropertyName("waitOperations"); change->setValue(QVariant::fromValue(newValue)); backendMemoryBarrier.sceneChangeEvent(change); // THEN - QCOMPARE(backendMemoryBarrier.barrierTypes(), newValue); + QCOMPARE(backendMemoryBarrier.waitOperations(), newValue); } } diff --git a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp index 6aef510ea..bf5f0d55f 100644 --- a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp +++ b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp @@ -46,7 +46,7 @@ public: bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE { - return functor_cast<MeshFunctorA>(&other); + return Qt3DRender::functor_cast<MeshFunctorA>(&other); } QT3D_FUNCTOR(MeshFunctorA) @@ -68,7 +68,7 @@ public: bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE { - return functor_cast<MeshFunctorB>(&other); + return Qt3DRender::functor_cast<MeshFunctorB>(&other); } QT3D_FUNCTOR(MeshFunctorB) @@ -85,7 +85,7 @@ public: bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_OVERRIDE { - return functor_cast<MeshFunctorASub>(&other); + return Qt3DRender::functor_cast<MeshFunctorASub>(&other); } QT3D_FUNCTOR(MeshFunctorASub) diff --git a/tests/auto/render/objectpicker/tst_objectpicker.cpp b/tests/auto/render/objectpicker/tst_objectpicker.cpp index 9140bb503..c1b06ccd8 100644 --- a/tests/auto/render/objectpicker/tst_objectpicker.cpp +++ b/tests/auto/render/objectpicker/tst_objectpicker.cpp @@ -33,7 +33,6 @@ #include <Qt3DRender/qobjectpicker.h> #include <Qt3DCore/private/qbackendnode_p.h> #include <Qt3DCore/qpropertyupdatedchange.h> -#include <Qt3DCore/private/qpropertyupdatedchangebase_p.h> #include "testpostmanarbiter.h" #include "testrenderer.h" @@ -113,7 +112,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "pressed"); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); @@ -124,7 +122,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "released"); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); @@ -135,7 +132,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "clicked"); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); @@ -146,7 +142,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "entered"); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); @@ -157,7 +152,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "exited"); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); } diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp index 5ebf10338..1d391101e 100644 --- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp +++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp @@ -809,13 +809,13 @@ private Q_SLOTS: QVERIFY(!backendPicker1->isPressed()); QCOMPARE(arbiter.events.count(), 2); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "clicked"); + QCOMPARE(change->propertyName(), "released"); pickEvent = change->value().value<Qt3DRender::QPickEventPtr>(); QVERIFY(pickEvent); if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking) QVERIFY(pickEvent.dynamicCast<Qt3DRender::QPickTriangleEvent>()); change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "released"); + QCOMPARE(change->propertyName(), "clicked"); pickEvent = change->value().value<Qt3DRender::QPickEventPtr>(); QVERIFY(pickEvent); if (pickMethod == Qt3DRender::QPickingSettings::TrianglePicking) @@ -1034,9 +1034,9 @@ private Q_SLOTS: QVERIFY(!backendPicker->isPressed()); QCOMPARE(arbiter.events.count(), 2); change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "clicked"); - change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "released"); + change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "clicked"); arbiter.events.clear(); @@ -1145,7 +1145,10 @@ private Q_SLOTS: change = arbiter1.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "moved"); } else { + QVERIFY(arbiter2.events.size() > 1); change = arbiter2.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "moved"); + change = arbiter2.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "entered"); } diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp index a65f27cb6..fdc25cbca 100644 --- a/tests/auto/render/qbuffer/tst_qbuffer.cpp +++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp @@ -51,7 +51,7 @@ public: bool operator ==(const Qt3DRender::QBufferDataGenerator &other) const Q_DECL_FINAL { - const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other); + const TestFunctor *otherFunctor = Qt3DRender::functor_cast<TestFunctor>(&other); if (otherFunctor != nullptr) return otherFunctor->m_size == m_size; return false; diff --git a/tests/auto/render/qcameralens/tst_qcameralens.cpp b/tests/auto/render/qcameralens/tst_qcameralens.cpp index aab43d553..adff66dc5 100644 --- a/tests/auto/render/qcameralens/tst_qcameralens.cpp +++ b/tests/auto/render/qcameralens/tst_qcameralens.cpp @@ -63,6 +63,7 @@ private Q_SLOTS: QCOMPARE(cameraLens.right(), 0.5f); QCOMPARE(cameraLens.bottom(), -0.5f); QCOMPARE(cameraLens.top(), 0.5f); + QCOMPARE(cameraLens.exposure(), 0.0f); } void checkPropertyChanges() @@ -243,6 +244,26 @@ private Q_SLOTS: } { // WHEN + QSignalSpy spy(&cameraLens, SIGNAL(exposureChanged(float))); + const float newValue = -2.0f; + cameraLens.setExposure(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(cameraLens.exposure(), newValue); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().toFloat(), -2.0f); + + // WHEN + spy.clear(); + cameraLens.setExposure(newValue); + + // THEN + QCOMPARE(cameraLens.exposure(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN QSignalSpy spy(&cameraLens, SIGNAL(projectionMatrixChanged(QMatrix4x4))); QMatrix4x4 newValue; newValue.translate(5.0f, 2.0f, 4.3f); @@ -340,6 +361,7 @@ private Q_SLOTS: cameraLens.setFarPlane(1005.0f); cameraLens.setFieldOfView(35.0f); cameraLens.setAspectRatio(16.0f/9.0f); + cameraLens.setExposure(1.0f); // WHEN QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; @@ -357,6 +379,7 @@ private Q_SLOTS: const Qt3DRender::QCameraLensData cloneData = creationChangeData->data; QCOMPARE(cameraLens.projectionMatrix(), cloneData.projectionMatrix); + QCOMPARE(cameraLens.exposure(), cloneData.exposure); QCOMPARE(cameraLens.id(), creationChangeData->subjectId()); QCOMPARE(cameraLens.isEnabled(), true); QCOMPARE(cameraLens.isEnabled(), creationChangeData->isNodeEnabled()); @@ -379,6 +402,7 @@ private Q_SLOTS: const Qt3DRender::QCameraLensData cloneData = creationChangeData->data; QCOMPARE(cameraLens.projectionMatrix(), cloneData.projectionMatrix); + QCOMPARE(cameraLens.exposure(), cloneData.exposure); QCOMPARE(cameraLens.id(), creationChangeData->subjectId()); QCOMPARE(cameraLens.isEnabled(), false); QCOMPARE(cameraLens.isEnabled(), creationChangeData->isNodeEnabled()); @@ -674,6 +698,38 @@ private Q_SLOTS: } + void checkExposureUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QCameraLens cameraLens; + arbiter.setArbiterOnNode(&cameraLens); + + { + // WHEN + cameraLens.setExposure(2.0f); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "exposure"); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + cameraLens.setExposure(2.0f); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + void checkProjectionMatrixUpdate() { // GIVEN diff --git a/tests/auto/render/qenvironmentlight/qenvironmentlight.pro b/tests/auto/render/qenvironmentlight/qenvironmentlight.pro new file mode 100644 index 000000000..8a66f65ba --- /dev/null +++ b/tests/auto/render/qenvironmentlight/qenvironmentlight.pro @@ -0,0 +1,11 @@ +TEMPLATE = app + +TARGET = tst_environmentlight + +QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib + +CONFIG += testcase + +SOURCES += tst_qenvironmentlight.cpp + +include(../../core/common/common.pri) diff --git a/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp b/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp new file mode 100644 index 000000000..76b3603c9 --- /dev/null +++ b/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp @@ -0,0 +1,301 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QTest> +#include <QSignalSpy> + +#include <Qt3DRender/qtexture.h> +#include <Qt3DRender/qenvironmentlight.h> +#include <Qt3DRender/private/qenvironmentlight_p.h> +#include <Qt3DRender/private/qshaderdata_p.h> + +#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> +#include <Qt3DCore/qnodecreatedchange.h> +#include "testpostmanarbiter.h" + +class tst_QEnvironmentLight: public QObject +{ + Q_OBJECT +private Q_SLOTS: + void checkDefaultConstruction() + { + // GIVEN + Qt3DRender::QEnvironmentLight light; + + // THEN + QVERIFY(light.findChild<Qt3DRender::QShaderData*>()); + QCOMPARE(light.irradiance(), nullptr); + QCOMPARE(light.specular(), nullptr); + } + + void shouldTakeOwnershipOfParentlessTextures() + { + // GIVEN + Qt3DRender::QEnvironmentLight light; + auto irradiance = new Qt3DRender::QTexture2D; + auto specular = new Qt3DRender::QTexture2D; + + // WHEN + light.setIrradiance(irradiance); + light.setSpecular(specular); + + // THEN + QCOMPARE(irradiance->parent(), &light); + QCOMPARE(specular->parent(), &light); + } + + void shouldNotChangeOwnershipOfParentedTextures() + { + // GIVEN + Qt3DCore::QNode node; + Qt3DRender::QEnvironmentLight light; + auto irradiance = new Qt3DRender::QTexture2D(&node); + auto specular = new Qt3DRender::QTexture2D(&node); + + // WHEN + light.setIrradiance(irradiance); + light.setSpecular(specular); + + // WHEN + delete irradiance; + delete specular; + + // THEN + } + + void checkPropertyChanges() + { + // GIVEN + Qt3DRender::QEnvironmentLight light; + auto shaderData = light.findChild<Qt3DRender::QShaderData*>(); + + { + auto texture = new Qt3DRender::QTexture2D(&light); + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::irradianceChanged); + + // WHEN + light.setIrradiance(texture); + + // THEN + QCOMPARE(light.irradiance(), texture); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + light.setIrradiance(texture); + + // THEN + QCOMPARE(light.irradiance(), texture); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 0); + + // WHEN + light.setIrradiance(nullptr); + + // THEN + QCOMPARE(light.irradiance(), nullptr); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + { + auto texture = new Qt3DRender::QTexture2D(&light); + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::irradianceChanged); + + // WHEN + light.setIrradiance(texture); + + // THEN + QCOMPARE(light.irradiance(), texture); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + delete texture; + + // THEN + QCOMPARE(light.irradiance(), nullptr); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + { + auto texture = new Qt3DRender::QTexture2D; + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::irradianceChanged); + + // WHEN + light.setIrradiance(texture); + + // THEN + QCOMPARE(light.irradiance(), texture); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + delete texture; + + // THEN + QCOMPARE(light.irradiance(), nullptr); + QCOMPARE(shaderData->property("irradiance").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + { + auto texture = new Qt3DRender::QTexture2D(&light); + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::specularChanged); + + // WHEN + light.setSpecular(texture); + + // THEN + QCOMPARE(light.specular(), texture); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + light.setSpecular(texture); + + // THEN + QCOMPARE(light.specular(), texture); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 0); + + // WHEN + light.setSpecular(nullptr); + + // THEN + QCOMPARE(light.specular(), nullptr); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + { + auto texture = new Qt3DRender::QTexture2D(&light); + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::specularChanged); + + // WHEN + light.setSpecular(texture); + + // THEN + QCOMPARE(light.specular(), texture); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + delete texture; + + // THEN + QCOMPARE(light.specular(), nullptr); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + { + auto texture = new Qt3DRender::QTexture2D; + QSignalSpy spy(&light, &Qt3DRender::QEnvironmentLight::specularChanged); + + // WHEN + light.setSpecular(texture); + + // THEN + QCOMPARE(light.specular(), texture); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), texture); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), texture); + + // WHEN + delete texture; + + // THEN + QCOMPARE(light.specular(), nullptr); + QCOMPARE(shaderData->property("specular").value<Qt3DRender::QAbstractTexture*>(), nullptr); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.takeFirst().first().value<Qt3DRender::QAbstractTexture*>(), nullptr); + } + } + + void checkCreationData() + { + // GIVEN + Qt3DRender::QEnvironmentLight light; + auto shaderData = light.findChild<Qt3DRender::QShaderData*>(); + + // WHEN + QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&light); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 2); // EnvironmentLight + ShaderData + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEnvironmentLightData>>(creationChanges.first()); + const Qt3DRender::QEnvironmentLightData cloneData = creationChangeData->data; + + QCOMPARE(cloneData.shaderDataId, shaderData->id()); + QCOMPARE(light.id(), creationChangeData->subjectId()); + QCOMPARE(light.isEnabled(), true); + QCOMPARE(light.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(light.metaObject(), creationChangeData->metaObject()); + } + + // WHEN + light.setEnabled(false); + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&light); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 2); // EnvironmentLight + ShaderData + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEnvironmentLightData>>(creationChanges.first()); + const Qt3DRender::QEnvironmentLightData cloneData = creationChangeData->data; + + QCOMPARE(cloneData.shaderDataId, shaderData->id()); + QCOMPARE(light.id(), creationChangeData->subjectId()); + QCOMPARE(light.isEnabled(), false); + QCOMPARE(light.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(light.metaObject(), creationChangeData->metaObject()); + } + } +}; + +QTEST_MAIN(tst_QEnvironmentLight) + +#include "tst_qenvironmentlight.moc" diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp index 76c3288e3..94f720097 100644 --- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp +++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp @@ -58,7 +58,7 @@ public: bool operator ==(const Qt3DRender::QGeometryFactory &other) const Q_DECL_FINAL { - const TestFactory *otherFactory = functor_cast<TestFactory>(&other); + const TestFactory *otherFactory = Qt3DRender::functor_cast<TestFactory>(&other); if (otherFactory != nullptr) return otherFactory->m_size == m_size; return false; diff --git a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp index e2ffdd9da..ba357c8c9 100644 --- a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp +++ b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp @@ -89,14 +89,14 @@ private Q_SLOTS: { // WHEN - lod->setThresholdType(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize); + lod->setThresholdType(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold); QCoreApplication::processEvents(); // THEN QCOMPARE(arbiter.events.size(), 1); Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "thresholdType"); - QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSize)); + QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold)); arbiter.events.clear(); } diff --git a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp index 87c813a03..25ee10cad 100644 --- a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp +++ b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp @@ -45,7 +45,7 @@ private Q_SLOTS: void initTestCase() { - qRegisterMetaType<Qt3DRender::QMemoryBarrier::BarrierTypes>("QMemoryBarrier::BarrierTypes"); + qRegisterMetaType<Qt3DRender::QMemoryBarrier::Operations>("QMemoryBarrier::Operations"); } void checkDefaultConstruction() @@ -54,7 +54,7 @@ private Q_SLOTS: Qt3DRender::QMemoryBarrier memoryBarrier; // THEN - QCOMPARE(memoryBarrier.barrierTypes(), Qt3DRender::QMemoryBarrier::None); + QCOMPARE(memoryBarrier.waitOperations(), Qt3DRender::QMemoryBarrier::None); } void checkPropertyChanges() @@ -64,21 +64,21 @@ private Q_SLOTS: { // WHEN - QSignalSpy spy(&memoryBarrier, SIGNAL(barrierTypesChanged(QMemoryBarrier::BarrierTypes))); - const Qt3DRender::QMemoryBarrier::BarrierTypes newValue(Qt3DRender::QMemoryBarrier::ShaderStorageBarrier|Qt3DRender::QMemoryBarrier::VertexAttributeArrayBarrier); - memoryBarrier.setBarrierTypes(newValue); + QSignalSpy spy(&memoryBarrier, SIGNAL(waitOperationsChanged(QMemoryBarrier::Operations))); + const Qt3DRender::QMemoryBarrier::Operations newValue(Qt3DRender::QMemoryBarrier::ShaderStorage|Qt3DRender::QMemoryBarrier::VertexAttributeArray); + memoryBarrier.setWaitOperations(newValue); // THEN QVERIFY(spy.isValid()); - QCOMPARE(memoryBarrier.barrierTypes(), newValue); + QCOMPARE(memoryBarrier.waitOperations(), newValue); QCOMPARE(spy.count(), 1); // WHEN spy.clear(); - memoryBarrier.setBarrierTypes(newValue); + memoryBarrier.setWaitOperations(newValue); // THEN - QCOMPARE(memoryBarrier.barrierTypes(), newValue); + QCOMPARE(memoryBarrier.waitOperations(), newValue); QCOMPARE(spy.count(), 0); } } @@ -88,7 +88,7 @@ private Q_SLOTS: // GIVEN Qt3DRender::QMemoryBarrier memoryBarrier; - memoryBarrier.setBarrierTypes(Qt3DRender::QMemoryBarrier::CommandBarrier); + memoryBarrier.setWaitOperations(Qt3DRender::QMemoryBarrier::Command); // WHEN QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; @@ -105,7 +105,7 @@ private Q_SLOTS: const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMemoryBarrierData>>(creationChanges.first()); const Qt3DRender::QMemoryBarrierData cloneData = creationChangeData->data; - QCOMPARE(memoryBarrier.barrierTypes(), cloneData.barrierTypes); + QCOMPARE(memoryBarrier.waitOperations(), cloneData.waitOperations); QCOMPARE(memoryBarrier.id(), creationChangeData->subjectId()); QCOMPARE(memoryBarrier.isEnabled(), true); QCOMPARE(memoryBarrier.isEnabled(), creationChangeData->isNodeEnabled()); @@ -127,7 +127,7 @@ private Q_SLOTS: const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMemoryBarrierData>>(creationChanges.first()); const Qt3DRender::QMemoryBarrierData cloneData = creationChangeData->data; - QCOMPARE(memoryBarrier.barrierTypes(), cloneData.barrierTypes); + QCOMPARE(memoryBarrier.waitOperations(), cloneData.waitOperations); QCOMPARE(memoryBarrier.id(), creationChangeData->subjectId()); QCOMPARE(memoryBarrier.isEnabled(), false); QCOMPARE(memoryBarrier.isEnabled(), creationChangeData->isNodeEnabled()); @@ -144,14 +144,14 @@ private Q_SLOTS: { // WHEN - memoryBarrier.setBarrierTypes(Qt3DRender::QMemoryBarrier::ShaderStorageBarrier); + memoryBarrier.setWaitOperations(Qt3DRender::QMemoryBarrier::ShaderStorage); QCoreApplication::processEvents(); // THEN QCOMPARE(arbiter.events.size(), 1); auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "barrierTypes"); - QCOMPARE(change->value().value<Qt3DRender::QMemoryBarrier::BarrierTypes>(), memoryBarrier.barrierTypes()); + QCOMPARE(change->propertyName(), "waitOperations"); + QCOMPARE(change->value().value<Qt3DRender::QMemoryBarrier::Operations>(), memoryBarrier.waitOperations()); QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); arbiter.events.clear(); @@ -159,7 +159,7 @@ private Q_SLOTS: { // WHEN - memoryBarrier.setBarrierTypes(Qt3DRender::QMemoryBarrier::ShaderStorageBarrier); + memoryBarrier.setWaitOperations(Qt3DRender::QMemoryBarrier::ShaderStorage); QCoreApplication::processEvents(); // THEN diff --git a/tests/auto/render/qmesh/tst_qmesh.cpp b/tests/auto/render/qmesh/tst_qmesh.cpp index 2122d7eb5..a0278f4e4 100644 --- a/tests/auto/render/qmesh/tst_qmesh.cpp +++ b/tests/auto/render/qmesh/tst_qmesh.cpp @@ -121,7 +121,7 @@ private Q_SLOTS: const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryRendererData>>(creationChanges.first()); const Qt3DRender::QGeometryRendererData cloneData = creationChangeData->data; - Qt3DRender::MeshFunctor meshFunctor(mesh.source(), mesh.meshName()); + Qt3DRender::MeshLoaderFunctor meshFunctor(&mesh, nullptr); QVERIFY(meshFunctor == *cloneData.geometryFactory); QCOMPARE(mesh.id(), creationChangeData->subjectId()); @@ -169,7 +169,7 @@ private Q_SLOTS: QCOMPARE(change->propertyName(), "geometryFactory"); QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::MeshFunctor meshFunctor(mesh.source()); + Qt3DRender::MeshLoaderFunctor meshFunctor(&mesh, nullptr); Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>(); QVERIFY(meshFunctor == *factory); @@ -205,7 +205,7 @@ private Q_SLOTS: QCOMPARE(change->propertyName(), "geometryFactory"); QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::MeshFunctor meshFunctor(QUrl(), mesh.meshName()); + Qt3DRender::MeshLoaderFunctor meshFunctor(&mesh, nullptr); Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>(); QVERIFY(meshFunctor == *factory); diff --git a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp index ef1e9f53c..e0037f3dd 100644 --- a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp +++ b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp @@ -67,7 +67,7 @@ private Q_SLOTS: arbiter.setArbiterOnNode(renderCapture.data()); // WHEN - QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(12)); + QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture()); // THEN QCOMPARE(arbiter.events.size(), 1); @@ -75,7 +75,7 @@ private Q_SLOTS: QCOMPARE(change->propertyName(), "renderCaptureRequest"); QCOMPARE(change->subjectId(),renderCapture->id()); QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - QCOMPARE(change->value().toInt(), 12); + QCOMPARE(change->value().toInt(), 1); arbiter.events.clear(); } @@ -84,12 +84,12 @@ private Q_SLOTS: { // GIVEN QScopedPointer<MyRenderCapture> renderCapture(new MyRenderCapture()); - QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(52)); + QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture()); QImage img = QImage(20, 20, QImage::Format_ARGB32); // WHEN Qt3DRender::RenderCaptureDataPtr data = Qt3DRender::RenderCaptureDataPtr::create(); - data.data()->captureId = 52; + data.data()->captureId = 2; data.data()->image = img; auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(renderCapture->id()); @@ -101,7 +101,6 @@ private Q_SLOTS: // THEN QCOMPARE(reply->isComplete(), true); - QCOMPARE(reply->captureId(), 52); QCOMPARE(reply->image().width(), 20); QCOMPARE(reply->image().height(), 20); QCOMPARE(reply->image().format(), QImage::Format_ARGB32); diff --git a/tests/auto/render/qscene2d/qscene2d.pro b/tests/auto/render/qscene2d/qscene2d.pro new file mode 100644 index 000000000..b1d4d45a9 --- /dev/null +++ b/tests/auto/render/qscene2d/qscene2d.pro @@ -0,0 +1,12 @@ +TEMPLATE = app + +TARGET = qscene2d + +QT += 3dcore 3dcore-private 3drender 3drender-private testlib 3dquickscene2d 3dquickscene2d-private + +CONFIG += testcase + +SOURCES += tst_qscene2d.cpp + +include(../../core/common/common.pri) +include(../commons/commons.pri) diff --git a/tests/auto/render/qscene2d/tst_qscene2d.cpp b/tests/auto/render/qscene2d/tst_qscene2d.cpp new file mode 100644 index 000000000..846207456 --- /dev/null +++ b/tests/auto/render/qscene2d/tst_qscene2d.cpp @@ -0,0 +1,316 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QTest> +#include <Qt3DQuickScene2D/qscene2d.h> +#include <Qt3DRender/qrendertargetoutput.h> +#include <private/qscene2d_p.h> +#include <QObject> +#include <QSignalSpy> +#include <Qt3DCore/qpropertyupdatedchange.h> +#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> +#include <Qt3DCore/qnodecreatedchange.h> +#include "testpostmanarbiter.h" + +using namespace Qt3DRender::Quick; + +class tst_QScene2D : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + + void initTestCase() + { + qRegisterMetaType<Qt3DRender::Quick::QScene2D::RenderPolicy>( + "QScene2D::RenderPolicy"); + } + + void checkDefaultConstruction() + { + // GIVEN + Qt3DRender::Quick::QScene2D scene2d; + + // THEN + QCOMPARE(scene2d.output(), nullptr); + QCOMPARE(scene2d.renderPolicy(), QScene2D::Continuous); + QCOMPARE(scene2d.item(), nullptr); + QCOMPARE(scene2d.isMouseEnabled(), true); + } + + void checkPropertyChanges() + { + // GIVEN + Qt3DRender::Quick::QScene2D scene2d; + QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput()); + QScopedPointer<QQuickItem> item(new QQuickItem()); + + { + // WHEN + QSignalSpy spy(&scene2d, SIGNAL(outputChanged(Qt3DRender::QRenderTargetOutput*))); + Qt3DRender::QRenderTargetOutput *newValue = output.data(); + scene2d.setOutput(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(scene2d.output(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + scene2d.setOutput(newValue); + + // THEN + QCOMPARE(scene2d.output(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&scene2d, SIGNAL(renderPolicyChanged(QScene2D::RenderPolicy))); + const QScene2D::RenderPolicy newValue = QScene2D::SingleShot; + scene2d.setRenderPolicy(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(scene2d.renderPolicy(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + scene2d.setRenderPolicy(newValue); + + // THEN + QCOMPARE(scene2d.renderPolicy(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&scene2d, SIGNAL(itemChanged(QQuickItem*))); + QQuickItem *newValue = item.data(); + scene2d.setItem(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(scene2d.item(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + scene2d.setItem(newValue); + + // THEN + QCOMPARE(scene2d.item(), newValue); + QCOMPARE(spy.count(), 0); + } + + { + // WHEN + QSignalSpy spy(&scene2d, SIGNAL(mouseEnabledChanged(bool))); + bool newValue = false; + scene2d.setMouseEnabled(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(scene2d.isMouseEnabled(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + scene2d.setMouseEnabled(newValue); + + // THEN + QCOMPARE(scene2d.isMouseEnabled(), newValue); + QCOMPARE(spy.count(), 0); + } + } + + void checkCreationData() + { + // GIVEN + Qt3DRender::Quick::QScene2D scene2d; + QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput()); + + scene2d.setOutput(output.data()); + scene2d.setRenderPolicy(QScene2D::SingleShot); + + // WHEN + QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&scene2d); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 1); + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange< + Qt3DRender::Quick::QScene2DData>>(creationChanges.first()); + const Qt3DRender::Quick::QScene2DData cloneData = creationChangeData->data; + + QCOMPARE(scene2d.output()->id(), cloneData.output); + QCOMPARE(scene2d.renderPolicy(), cloneData.renderPolicy); + QCOMPARE(scene2d.id(), creationChangeData->subjectId()); + QCOMPARE(scene2d.isEnabled(), true); + QCOMPARE(scene2d.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(scene2d.metaObject(), creationChangeData->metaObject()); + QCOMPARE(scene2d.isMouseEnabled(), cloneData.mouseEnabled); + } + + // WHEN + scene2d.setEnabled(false); + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&scene2d); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 1); + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange< + Qt3DRender::Quick::QScene2DData>>(creationChanges.first()); + const Qt3DRender::Quick::QScene2DData cloneData = creationChangeData->data; + + QCOMPARE(scene2d.output()->id(), cloneData.output); + QCOMPARE(scene2d.renderPolicy(), cloneData.renderPolicy); + QCOMPARE(scene2d.id(), creationChangeData->subjectId()); + QCOMPARE(scene2d.isEnabled(), false); + QCOMPARE(scene2d.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(scene2d.metaObject(), creationChangeData->metaObject()); + } + } + + void checkOutputUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::Quick::QScene2D scene2d; + arbiter.setArbiterOnNode(&scene2d); + QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput()); + + { + // WHEN + scene2d.setOutput(output.data()); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "output"); + QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), scene2d.output()->id()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + scene2d.setOutput(output.data()); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkRenderPolicyUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::Quick::QScene2D scene2d; + arbiter.setArbiterOnNode(&scene2d); + + { + // WHEN + scene2d.setRenderPolicy(QScene2D::SingleShot); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "renderPolicy"); + QCOMPARE(change->value().value<Qt3DRender::Quick::QScene2D::RenderPolicy>(), + scene2d.renderPolicy()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + scene2d.setRenderPolicy(QScene2D::SingleShot); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkMouseEnabledUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::Quick::QScene2D scene2d; + arbiter.setArbiterOnNode(&scene2d); + + { + // WHEN + scene2d.setMouseEnabled(false); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "mouseEnabled"); + QCOMPARE(change->value().toBool(), scene2d.isMouseEnabled()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + scene2d.setMouseEnabled(false); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + +}; + +QTEST_MAIN(tst_QScene2D) + +#include "tst_qscene2d.moc" diff --git a/tests/auto/render/qshaderprogram/qshaderprogram.pro b/tests/auto/render/qshaderprogram/qshaderprogram.pro new file mode 100644 index 000000000..6f40caee9 --- /dev/null +++ b/tests/auto/render/qshaderprogram/qshaderprogram.pro @@ -0,0 +1,12 @@ +TEMPLATE = app + +TARGET = tst_qshaderprogram + +QT += 3dcore 3dcore-private 3drender 3drender-private testlib + +CONFIG += testcase + +SOURCES += tst_qshaderprogram.cpp + +include(../../core/common/common.pri) +include(../commons/commons.pri) diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp new file mode 100644 index 000000000..901ee7349 --- /dev/null +++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp @@ -0,0 +1,518 @@ +/**************************************************************************** +** +** Copyright (C) 2016 Paul Lemire <paul.lemire350@gmail.com> +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include <QtTest/QTest> +#include <Qt3DRender/qshaderprogram.h> +#include <Qt3DRender/private/qshaderprogram_p.h> +#include <QObject> +#include <QSignalSpy> +#include <Qt3DCore/qpropertyupdatedchange.h> +#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> +#include <Qt3DCore/qnodecreatedchange.h> +#include "testpostmanarbiter.h" + +// We need to call QShaderProgram::sceneChangeEvent +class tst_QShaderProgram : public Qt3DRender::QShaderProgram +{ + Q_OBJECT + +private Q_SLOTS: + + void checkDefaultConstruction() + { + // GIVEN + Qt3DRender::QShaderProgram shaderProgram; + + // THEN + QCOMPARE(shaderProgram.vertexShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.tessellationControlShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.geometryShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.fragmentShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.computeShaderCode(), QByteArray()); + QCOMPARE(shaderProgram.log(), QString()); + QCOMPARE(shaderProgram.status(), Qt3DRender::QShaderProgram::NotReady); + } + + void checkPropertyChanges() + { + // GIVEN + Qt3DRender::QShaderProgram shaderProgram; + + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(vertexShaderCodeChanged(QByteArray))); + const QByteArray newValue = "VERTEX"; + shaderProgram.setVertexShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.vertexShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setVertexShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.vertexShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(tessellationControlShaderCodeChanged(QByteArray))); + const QByteArray newValue = "TESSELATION_CONTROL"; + shaderProgram.setTessellationControlShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.tessellationControlShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setTessellationControlShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.tessellationControlShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(tessellationEvaluationShaderCodeChanged(QByteArray))); + const QByteArray newValue = "TESSELATION_EVALUTATION"; + shaderProgram.setTessellationEvaluationShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setTessellationEvaluationShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(geometryShaderCodeChanged(QByteArray))); + const QByteArray newValue = "GEOMETRY"; + shaderProgram.setGeometryShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.geometryShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setGeometryShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.geometryShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(fragmentShaderCodeChanged(QByteArray))); + const QByteArray newValue = "FRAGMENT"; + shaderProgram.setFragmentShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.fragmentShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setFragmentShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.fragmentShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + { + // WHEN + QSignalSpy spy(&shaderProgram, SIGNAL(computeShaderCodeChanged(QByteArray))); + const QByteArray newValue = "COMPUTE"; + shaderProgram.setComputeShaderCode(newValue); + + // THEN + QVERIFY(spy.isValid()); + QCOMPARE(shaderProgram.computeShaderCode(), newValue); + QCOMPARE(spy.count(), 1); + + // WHEN + spy.clear(); + shaderProgram.setComputeShaderCode(newValue); + + // THEN + QCOMPARE(shaderProgram.computeShaderCode(), newValue); + QCOMPARE(spy.count(), 0); + } + } + + void checkCreationData() + { + // GIVEN + Qt3DRender::QShaderProgram shaderProgram; + + shaderProgram.setVertexShaderCode(QByteArrayLiteral("Vertex")); + shaderProgram.setTessellationControlShaderCode(QByteArrayLiteral("TesselControl")); + shaderProgram.setTessellationEvaluationShaderCode(QByteArrayLiteral("TesselEval")); + shaderProgram.setGeometryShaderCode(QByteArrayLiteral("Geometry")); + shaderProgram.setFragmentShaderCode(QByteArrayLiteral("Fragment")); + shaderProgram.setComputeShaderCode(QByteArrayLiteral("Compute")); + + // WHEN + QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderProgram); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 1); + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramData>>(creationChanges.first()); + const Qt3DRender::QShaderProgramData cloneData = creationChangeData->data; + + QCOMPARE(shaderProgram.vertexShaderCode(), cloneData.vertexShaderCode); + QCOMPARE(shaderProgram.tessellationControlShaderCode(), cloneData.tessellationControlShaderCode); + QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), cloneData.tessellationEvaluationShaderCode); + QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode); + QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode); + QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode); + QCOMPARE(shaderProgram.id(), creationChangeData->subjectId()); + QCOMPARE(shaderProgram.isEnabled(), true); + QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(shaderProgram.metaObject(), creationChangeData->metaObject()); + } + + // WHEN + shaderProgram.setEnabled(false); + + { + Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderProgram); + creationChanges = creationChangeGenerator.creationChanges(); + } + + // THEN + { + QCOMPARE(creationChanges.size(), 1); + + const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramData>>(creationChanges.first()); + const Qt3DRender::QShaderProgramData cloneData = creationChangeData->data; + + QCOMPARE(shaderProgram.vertexShaderCode(), cloneData.vertexShaderCode); + QCOMPARE(shaderProgram.tessellationControlShaderCode(), cloneData.tessellationControlShaderCode); + QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), cloneData.tessellationEvaluationShaderCode); + QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode); + QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode); + QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode); + QCOMPARE(shaderProgram.id(), creationChangeData->subjectId()); + QCOMPARE(shaderProgram.isEnabled(), false); + QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled()); + QCOMPARE(shaderProgram.metaObject(), creationChangeData->metaObject()); + } + } + + void checkVertexShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setVertexShaderCode(QByteArrayLiteral("in vec3 toto;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "vertexShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.vertexShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setVertexShaderCode(QByteArrayLiteral("in vec3 toto;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkTessellationControlShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setTessellationControlShaderCode(QByteArrayLiteral("in vec3 toto2;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "tessellationControlShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.tessellationControlShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setTessellationControlShaderCode(QByteArrayLiteral("in vec3 toto2;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkTessellationEvaluationShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setTessellationEvaluationShaderCode(QByteArrayLiteral("in vec3 toto3;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "tessellationEvaluationShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.tessellationEvaluationShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setTessellationEvaluationShaderCode(QByteArrayLiteral("in vec3 toto3;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkGeometryShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setGeometryShaderCode(QByteArrayLiteral("in vec3 toto4;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "geometryShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.geometryShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setGeometryShaderCode(QByteArrayLiteral("in vec3 toto4;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkFragmentShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setFragmentShaderCode(QByteArrayLiteral("out vec4 fragColor;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "fragmentShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.fragmentShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setFragmentShaderCode(QByteArrayLiteral("out vec4 fragColor;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkComputeShaderCodeUpdate() + { + // GIVEN + TestArbiter arbiter; + Qt3DRender::QShaderProgram shaderProgram; + arbiter.setArbiterOnNode(&shaderProgram); + + { + // WHEN + shaderProgram.setComputeShaderCode(QByteArrayLiteral("uniform vec3 temp;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "computeShaderCode"); + QCOMPARE(change->value().value<QByteArray>(), shaderProgram.computeShaderCode()); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + } + + { + // WHEN + shaderProgram.setComputeShaderCode(QByteArrayLiteral("uniform vec3 temp;")); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + } + + } + + void checkLogPropertyUpdate() + { + // GIVEN + TestArbiter arbiter; + arbiter.setArbiterOnNode(this); + QSignalSpy spy(this, SIGNAL(logChanged(QString))); + const QString logValue = QStringLiteral("Some log..."); + + // THEN + QVERIFY(spy.isValid()); + + // WHEN + Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); + valueChange->setPropertyName("log"); + valueChange->setValue(QVariant::fromValue(logValue)); + sceneChangeEvent(valueChange); + + // THEN + QCOMPARE(spy.count(), 1); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(log(), logValue); + + // WHEN + spy.clear(); + sceneChangeEvent(valueChange); + + // THEN + QCOMPARE(spy.count(), 0); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(log(), logValue); + } + + void checkStatusPropertyUpdate() + { + // GIVEN + qRegisterMetaType<Qt3DRender::QShaderProgram::Status>("Status"); + TestArbiter arbiter; + arbiter.setArbiterOnNode(this); + QSignalSpy spy(this, SIGNAL(statusChanged(Status))); + const Qt3DRender::QShaderProgram::Status newStatus = Qt3DRender::QShaderProgram::Error; + + // THEN + QVERIFY(spy.isValid()); + + // WHEN + Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); + valueChange->setPropertyName("status"); + valueChange->setValue(QVariant::fromValue(newStatus)); + sceneChangeEvent(valueChange); + + // THEN + QCOMPARE(spy.count(), 1); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(status(), newStatus); + + // WHEN + spy.clear(); + sceneChangeEvent(valueChange); + + // THEN + QCOMPARE(spy.count(), 0); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(status(), newStatus); + } + +}; + +QTEST_MAIN(tst_QShaderProgram) + +#include "tst_qshaderprogram.moc" diff --git a/tests/auto/render/qsortcriterion/tst_qsortcriterion.cpp b/tests/auto/render/qsortcriterion/tst_qsortcriterion.cpp deleted file mode 100644 index bac9fb3e8..000000000 --- a/tests/auto/render/qsortcriterion/tst_qsortcriterion.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB). -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the S module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include <QtTest/QTest> -#include <Qt3DCore/private/qnode_p.h> -#include <Qt3DCore/private/qscene_p.h> -#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> - -#include <Qt3DRender/qsortcriterion.h> -#include <Qt3DRender/private/qsortcriterion_p.h> - -#include "testpostmanarbiter.h" - -class tst_QSortCriterion: public QObject -{ - Q_OBJECT - -private Q_SLOTS: - - void checkCloning_data() - { - QTest::addColumn<Qt3DRender::QSortCriterion *>("sortCriterion"); - QTest::addColumn<Qt3DRender::QSortCriterion::SortType>("sortType"); - - Qt3DRender::QSortCriterion *defaultConstructed = new Qt3DRender::QSortCriterion(); - QTest::newRow("defaultConstructed") << defaultConstructed << Qt3DRender::QSortCriterion::StateChangeCost; - - Qt3DRender::QSortCriterion *backToFrontSort = new Qt3DRender::QSortCriterion(); - backToFrontSort->setSort(Qt3DRender::QSortCriterion::BackToFront); - QTest::newRow("backToFrontSort") << backToFrontSort << Qt3DRender::QSortCriterion::BackToFront; - - Qt3DRender::QSortCriterion *materialSort = new Qt3DRender::QSortCriterion(); - materialSort->setSort(Qt3DRender::QSortCriterion::Material); - QTest::newRow("materialSort") << materialSort << Qt3DRender::QSortCriterion::Material; - } - - void checkCloning() - { - // GIVEN - QFETCH(Qt3DRender::QSortCriterion *, sortCriterion); - QFETCH(Qt3DRender::QSortCriterion::SortType, sortType); - - // THEN - QCOMPARE(sortCriterion->sort(), sortType); - -// TO DO: Add creation change -// // WHEN -// Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(sortCriterion); -// QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges(); - -// // THEN -// QCOMPARE(creationChanges.size(), 1); - -// const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QCameraSelectorData> creationChangeData = -// qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSortCriterion>>(creationChanges.first()); -// const Qt3DRender::QCameraSelectorData &cloneData = creationChangeData->data; - - -// // THEN -// QCOMPARE(sortCriterion->id(), creationChangeData->subjectId()); -// QCOMPARE(sortCriterion->isEnabled(), creationChangeData->isNodeEnabled()); -// QCOMPARE(sortCriterion->metaObject(), creationChangeData->metaObject()); -// QCOMPARE(sortCriterion->sort(), cloneData.sort); - - delete sortCriterion; - } - - void checkPropertyUpdates() - { - // GIVEN - QScopedPointer<Qt3DRender::QSortCriterion> sortCriterion(new Qt3DRender::QSortCriterion()); - TestArbiter arbiter(sortCriterion.data()); - - // WHEN - sortCriterion->setSort(Qt3DRender::QSortCriterion::BackToFront); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QNodePropertyChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QNodePropertyChange>(); - QCOMPARE(change->propertyName(), "sort"); - QCOMPARE(change->subjectId(), sortCriterion->id()); - QCOMPARE(change->value().value<Qt3DRender::QSortCriterion::SortType>(), Qt3DRender::QSortCriterion::BackToFront); - QCOMPARE(change->type(), Qt3DCore::NodeUpdated); - - arbiter.events.clear(); - - // WHEN - sortCriterion->setSort(Qt3DRender::QSortCriterion::BackToFront); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 0); - - // WHEN - sortCriterion->setSort(Qt3DRender::QSortCriterion::Material); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QNodePropertyChange>(); - QCOMPARE(change->propertyName(), "sort"); - QCOMPARE(change->subjectId(), sortCriterion->id()); - QCOMPARE(change->value().value<Qt3DRender::QSortCriterion::SortType>(), Qt3DRender::QSortCriterion::Material); - QCOMPARE(change->type(), Qt3DCore::NodeUpdated); - - arbiter.events.clear(); - } -}; - -QTEST_MAIN(tst_QSortCriterion) - -#include "tst_qsortcriterion.moc" diff --git a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp index 252bc85af..56ad55adf 100644 --- a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp +++ b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp @@ -51,6 +51,13 @@ private Q_SLOTS: // THEN QCOMPARE(textureLoader.source(), QUrl()); QCOMPARE(textureLoader.isMirrored(), true); + QCOMPARE(textureLoader.target(), Qt3DRender::QTextureLoader::TargetAutomatic); + QCOMPARE(textureLoader.wrapMode()->x(), Qt3DRender::QTextureWrapMode::Repeat); + QCOMPARE(textureLoader.wrapMode()->y(), Qt3DRender::QTextureWrapMode::Repeat); + QCOMPARE(textureLoader.magnificationFilter(), Qt3DRender::QTextureLoader::Linear); + QCOMPARE(textureLoader.minificationFilter(), Qt3DRender::QTextureLoader::LinearMipMapLinear); + QCOMPARE(textureLoader.generateMipMaps(), true); + QCOMPARE(textureLoader.maximumAnisotropy(), 16.0f); } void checkPropertyChanges() diff --git a/tests/auto/render/qviewport/tst_qviewport.cpp b/tests/auto/render/qviewport/tst_qviewport.cpp index 87b22e22b..93a2735f2 100644 --- a/tests/auto/render/qviewport/tst_qviewport.cpp +++ b/tests/auto/render/qviewport/tst_qviewport.cpp @@ -46,14 +46,15 @@ private Q_SLOTS: { QTest::addColumn<Qt3DRender::QViewport *>("viewport"); QTest::addColumn<QRectF>("normalizedRect"); + QTest::addColumn<float>("gamma"); Qt3DRender::QViewport *defaultConstructed = new Qt3DRender::QViewport(); - QTest::newRow("defaultConstructed") << defaultConstructed << QRectF(0.0f, 0.0f, 1.0f, 1.0f); + QTest::newRow("defaultConstructed") << defaultConstructed << QRectF(0.0f, 0.0f, 1.0f, 1.0f) << 2.2f; Qt3DRender::QViewport *smallGreenViewport = new Qt3DRender::QViewport(); smallGreenViewport->setNormalizedRect(QRectF(0.2f, 0.2f, 0.6f, 0.6f)); - QTest::newRow("smallGreenViewport") << smallGreenViewport << QRectF(0.2f, 0.2f, 0.6f, 0.6f); - + smallGreenViewport->setGamma(1.8f); + QTest::newRow("smallGreenViewport") << smallGreenViewport << QRectF(0.2f, 0.2f, 0.6f, 0.6f) << 1.8f; } void checkCloning() @@ -61,9 +62,11 @@ private Q_SLOTS: // GIVEN QFETCH(Qt3DRender::QViewport *, viewport); QFETCH(QRectF, normalizedRect); + QFETCH(float, gamma); // THEN QCOMPARE(viewport->normalizedRect(), normalizedRect); + QCOMPARE(viewport->gamma(), gamma); // WHEN Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(viewport); @@ -80,6 +83,7 @@ private Q_SLOTS: QCOMPARE(viewport->isEnabled(), creationChangeData->isNodeEnabled()); QCOMPARE(viewport->metaObject(), creationChangeData->metaObject()); QCOMPARE(viewport->normalizedRect(), cloneData.normalizedRect); + QCOMPARE(viewport->gamma(), cloneData.gamma); delete viewport; } @@ -91,39 +95,77 @@ private Q_SLOTS: QScopedPointer<Qt3DRender::QViewport> viewport(new Qt3DRender::QViewport()); arbiter.setArbiterOnNode(viewport.data()); - // WHEN - viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f)); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "normalizedRect"); - QCOMPARE(change->subjectId(), viewport->id()); - QCOMPARE(change->value().value<QRectF>(), QRectF(0.5f, 0.5f, 1.0f, 1.0f)); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + { + // WHEN + viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f)); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "normalizedRect"); + QCOMPARE(change->subjectId(), viewport->id()); + QCOMPARE(change->value().value<QRectF>(), QRectF(0.5f, 0.5f, 1.0f, 1.0f)); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + + // WHEN + viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f)); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + + // WHEN + viewport->setNormalizedRect(QRectF(0.0f, 0.0f, 1.0f, 1.0f)); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "normalizedRect"); + QCOMPARE(change->subjectId(), viewport->id()); + QCOMPARE(change->value().value<QRectF>(), QRectF(0.0f, 0.0f, 1.0f, 1.0f)); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + } arbiter.events.clear(); - // WHEN - viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f)); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 0); - - // WHEN - viewport->setNormalizedRect(QRectF(0.0f, 0.0f, 1.0f, 1.0f)); - QCoreApplication::processEvents(); - - // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "normalizedRect"); - QCOMPARE(change->subjectId(), viewport->id()); - QCOMPARE(change->value().value<QRectF>(), QRectF(0.0f, 0.0f, 1.0f, 1.0f)); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - + { + // WHEN + viewport->setGamma(1.8f); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "gamma"); + QCOMPARE(change->subjectId(), viewport->id()); + QCOMPARE(change->value().toFloat(), 1.8f); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + + arbiter.events.clear(); + + // WHEN + viewport->setGamma(1.8f); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 0); + + // WHEN + viewport->setGamma(2.0f); + QCoreApplication::processEvents(); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); + QCOMPARE(change->propertyName(), "gamma"); + QCOMPARE(change->subjectId(), viewport->id()); + QCOMPARE(change->value().toFloat(), 2.0f); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + } } }; diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro index c1de2aff8..8eea3d032 100644 --- a/tests/auto/render/render.pro +++ b/tests/auto/render/render.pro @@ -31,6 +31,7 @@ qtConfig(private_tests) { qframegraphnode \ qlayerfilter \ qabstractlight \ + qenvironmentlight \ qray3d \ qrenderpassfilter \ qrendertargetselector \ @@ -45,6 +46,7 @@ qtConfig(private_tests) { picking \ # qboundingvolumedebug \ # boundingvolumedebug \ + boundingsphere \ qdefaultmeshes \ trianglesextractor \ triangleboundingvolume \ @@ -100,7 +102,12 @@ qtConfig(private_tests) { rendercapture \ trianglevisitor \ qmemorybarrier \ - memorybarrier + memorybarrier \ + qshaderprogram \ + qscene2d \ + scene2d \ + coordinatereader \ + framegraphvisitor !macos: SUBDIRS += graphicshelpergl4 } diff --git a/tests/auto/render/renderqueue/tst_renderqueue.cpp b/tests/auto/render/renderqueue/tst_renderqueue.cpp index 2d25cbe57..163a699c1 100644 --- a/tests/auto/render/renderqueue/tst_renderqueue.cpp +++ b/tests/auto/render/renderqueue/tst_renderqueue.cpp @@ -55,10 +55,14 @@ void tst_RenderQueue::setRenderViewCount() // GIVEN Qt3DRender::Render::RenderQueue renderQueue; + // THEN + QCOMPARE(renderQueue.wasReset(), true); + // WHEN renderQueue.setTargetRenderViewCount(7); // THEN + QCOMPARE(renderQueue.wasReset(), false); QVERIFY(renderQueue.targetRenderViewCount() == 7); QVERIFY(renderQueue.currentRenderViewCount()== 0); } @@ -214,6 +218,7 @@ void tst_RenderQueue::resetQueue() // WHEN renderQueue.setTargetRenderViewCount(5); // THEN + QCOMPARE(renderQueue.wasReset(), false); QVERIFY(renderQueue.currentRenderViewCount() == 0); // WHEN @@ -227,6 +232,7 @@ void tst_RenderQueue::resetQueue() // WHEN renderQueue.reset(); + QCOMPARE(renderQueue.wasReset(), true); // THEN QVERIFY(renderQueue.currentRenderViewCount() == 0); } diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp index 70109d718..d469298f4 100644 --- a/tests/auto/render/renderviews/tst_renderviews.cpp +++ b/tests/auto/render/renderviews/tst_renderviews.cpp @@ -93,7 +93,7 @@ private Q_SLOTS: QCOMPARE(renderView.memoryBarrier(), QMemoryBarrier::None); // WHEN - const QMemoryBarrier::BarrierTypes barriers(QMemoryBarrier::BufferUpdateBarrier|QMemoryBarrier::ShaderImageAccessBarrier); + const QMemoryBarrier::Operations barriers(QMemoryBarrier::BufferUpdate|QMemoryBarrier::ShaderImageAccess); renderView.setMemoryBarrier(barriers); // THEN @@ -104,7 +104,7 @@ private Q_SLOTS: { { // GIVEN - const QMemoryBarrier::BarrierTypes barriers(QMemoryBarrier::AtomicCounterBarrier|QMemoryBarrier::ShaderStorageBarrier); + const QMemoryBarrier::Operations barriers(QMemoryBarrier::AtomicCounter|QMemoryBarrier::ShaderStorage); Qt3DRender::QMemoryBarrier frontendBarrier; FrameGraphManager frameGraphManager; MemoryBarrier backendBarrier; @@ -113,18 +113,18 @@ private Q_SLOTS: backendBarrier.setFrameGraphManager(&frameGraphManager); // WHEN - frontendBarrier.setBarrierTypes(barriers); + frontendBarrier.setWaitOperations(barriers); simulateInitialization(&frontendBarrier, &backendBarrier); // THEN QCOMPARE(renderView.memoryBarrier(), QMemoryBarrier::None); - QCOMPARE(backendBarrier.barrierTypes(), barriers); + QCOMPARE(backendBarrier.waitOperations(), barriers); // WHEN Qt3DRender::Render::setRenderViewConfigFromFrameGraphLeafNode(&renderView, &backendBarrier); // THEN - QCOMPARE(backendBarrier.barrierTypes(), renderView.memoryBarrier()); + QCOMPARE(backendBarrier.waitOperations(), renderView.memoryBarrier()); } // TO DO: Complete tests for other framegraph node types } diff --git a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp index e4681a257..fa0dce6af 100644 --- a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp +++ b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp @@ -43,7 +43,10 @@ class tst_RenderViewUtils : public Qt3DCore::QBackendNodeTester private Q_SLOTS: void topLevelScalarValueNoUniforms(); void topLevelScalarValue(); + void topLevelTextureValueNoUniforms(); + void topLevelTextureValue(); void topLevelArrayValue(); + void nestedShaderDataValue(); void topLevelStructValue_data(); void topLevelStructValue(); void topLevelDynamicProperties(); @@ -66,6 +69,15 @@ private: // Init the backend element simulateInitialization(frontend, backend); } + + void initBackendTexture(Qt3DRender::QAbstractTexture *frontend, + Qt3DRender::Render::TextureManager *manager) + { + // Create backend element for frontend one + Qt3DRender::Render::Texture *backend = manager->getOrCreateResource(frontend->id()); + // Init the backend element + simulateInitialization(frontend, backend); + } }; class ScalarShaderData : public Qt3DRender::QShaderData @@ -74,8 +86,8 @@ class ScalarShaderData : public Qt3DRender::QShaderData Q_PROPERTY(float scalar READ scalar WRITE setScalar NOTIFY scalarChanged) public: - ScalarShaderData() - : Qt3DRender::QShaderData() + ScalarShaderData(Qt3DCore::QNode *parent = nullptr) + : Qt3DRender::QShaderData(parent) , m_scalar(0.0f) { } @@ -109,6 +121,47 @@ private: float m_scalar; }; +class TextureShaderData : public Qt3DRender::QShaderData +{ + Q_OBJECT + Q_PROPERTY(Qt3DRender::QAbstractTexture* texture READ texture WRITE setTexture NOTIFY textureChanged) + +public: + TextureShaderData() + : Qt3DRender::QShaderData() + , m_texture(nullptr) + { + } + + void setTexture(Qt3DRender::QAbstractTexture *texture) + { + if (texture != m_texture) { + m_texture = texture; + emit textureChanged(); + } + } + + Qt3DRender::QAbstractTexture *texture() const + { + return m_texture; + } + + QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName) + { + QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms; + + uniforms.insert(blockName + QStringLiteral(".texture"), Qt3DRender::Render::ShaderUniform()); + + return uniforms; + } + +Q_SIGNALS: + void textureChanged(); + +private: + Qt3DRender::QAbstractTexture *m_texture; +}; + class ArrayShaderData : public Qt3DRender::QShaderData { @@ -294,6 +347,7 @@ void tst_RenderViewUtils::topLevelScalarValueNoUniforms() // GIVEN QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData()); QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); // WHEN shaderData->setScalar(883.0f); @@ -306,6 +360,7 @@ void tst_RenderViewUtils::topLevelScalarValueNoUniforms() // WHEB Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); blockBuilder.updatedPropertiesOnly = false; // build name-value map blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("")); @@ -320,6 +375,7 @@ void tst_RenderViewUtils::topLevelScalarValue() // GIVEN QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData()); QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); // WHEN shaderData->setScalar(883.0f); @@ -332,6 +388,7 @@ void tst_RenderViewUtils::topLevelScalarValue() // WHEN Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); blockBuilder.updatedPropertiesOnly = false; blockBuilder.uniforms = shaderData->buildUniformMap(QStringLiteral("MyBlock")); // build name-value map @@ -353,11 +410,83 @@ void tst_RenderViewUtils::topLevelScalarValue() } } +void tst_RenderViewUtils::topLevelTextureValueNoUniforms() +{ + // GIVEN + QScopedPointer<TextureShaderData> shaderData(new TextureShaderData); + QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager); + QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); + + // WHEN + shaderData->setTexture(texture.data()); + initBackendShaderData(shaderData.data(), manager.data()); + + // THEN + Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id()); + QVERIFY(backendShaderData != nullptr); + + // WHEB + Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; + blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); + blockBuilder.updatedPropertiesOnly = false; + // build name-value map + blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("")); + + // THEN + // activeUniformNamesToValue should be empty as blockBuilder.uniforms is + QVERIFY(blockBuilder.activeUniformNamesToValue.isEmpty()); +} + +void tst_RenderViewUtils::topLevelTextureValue() +{ + // GIVEN + QScopedPointer<TextureShaderData> shaderData(new TextureShaderData); + QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager); + QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); + + // WHEN + initBackendTexture(texture.data(), textureManager.data()); + shaderData->setTexture(texture.data()); + initBackendShaderData(shaderData.data(), manager.data()); + + // THEN + Qt3DRender::Render::ShaderData *backendShaderData = manager->lookupResource(shaderData->id()); + QVERIFY(backendShaderData != nullptr); + + // WHEN + Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; + blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); + blockBuilder.updatedPropertiesOnly = false; + blockBuilder.uniforms = shaderData->buildUniformMap(QStringLiteral("MyBlock")); + // build name-value map + blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock")); + + // THEN + QVERIFY(blockBuilder.uniforms.count() == 1); + QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 1); + + // WHEN + Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin(); + const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end(); + + while (it != end) { + // THEN + QVERIFY(blockBuilder.uniforms.contains(Qt3DRender::Render::StringToInt::lookupString(it.key()))); + QCOMPARE(it.value(), QVariant::fromValue(shaderData->texture()->id())); + ++it; + } +} + void tst_RenderViewUtils::topLevelArrayValue() { // GIVEN QScopedPointer<ArrayShaderData> shaderData(new ArrayShaderData()); QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); // WHEN QVariantList arrayValues = QVariantList() << 454 << 350 << 383 << 427 << 552; @@ -371,6 +500,7 @@ void tst_RenderViewUtils::topLevelArrayValue() // WHEN Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); blockBuilder.updatedPropertiesOnly = false; blockBuilder.uniforms = shaderData->buildUniformMap(QStringLiteral("MyBlock")); // build name-value map @@ -392,6 +522,73 @@ void tst_RenderViewUtils::topLevelArrayValue() } } +void tst_RenderViewUtils::nestedShaderDataValue() +{ + // GIVEN + QScopedPointer<ArrayShaderData> arrayShaderData(new ArrayShaderData()); + QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); + + QScopedPointer<ScalarShaderData> shaderData1(new ScalarShaderData(arrayShaderData.data())); + QScopedPointer<ScalarShaderData> shaderData2(new ScalarShaderData(arrayShaderData.data())); + QScopedPointer<ScalarShaderData> shaderData3(new ScalarShaderData(arrayShaderData.data())); + + shaderData1->setScalar(883.0f); + shaderData2->setScalar(1200.0f); + shaderData3->setScalar(1340.0f); + QHash<QString, QVariant> scalarValues; + scalarValues[QStringLiteral("MyBlock.array[0].scalar")] = shaderData1->scalar(); + scalarValues[QStringLiteral("MyBlock.array[1].scalar")] = shaderData2->scalar(); + scalarValues[QStringLiteral("MyBlock.array[2].scalar")] = shaderData3->scalar(); + + + const Qt3DCore::QNodeId id1 = shaderData1->id(); + const Qt3DCore::QNodeId id2 = shaderData2->id(); + const Qt3DCore::QNodeId id3 = shaderData3->id(); + + // WHEN + const QVariantList arrayValues = QVariantList() << QVariant::fromValue(id1) << QVariant::fromValue(id2) << QVariant::fromValue(id3); + arrayShaderData->setArray(arrayValues); + initBackendShaderData(arrayShaderData.data(), manager.data()); + + // THEN + Qt3DRender::Render::ShaderData *backendArrayShaderData = manager->lookupResource(arrayShaderData->id()); + Qt3DRender::Render::ShaderData *backendShaderData1 = manager->lookupResource(id1); + Qt3DRender::Render::ShaderData *backendShaderData2 = manager->lookupResource(id2); + Qt3DRender::Render::ShaderData *backendShaderData3 = manager->lookupResource(id3); + QVERIFY(backendArrayShaderData != nullptr); + QVERIFY(backendShaderData1 != nullptr); + QVERIFY(backendShaderData2 != nullptr); + QVERIFY(backendShaderData3 != nullptr); + + // WHEN + Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; + blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); + blockBuilder.updatedPropertiesOnly = false; + blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0].scalar"), Qt3DRender::Render::ShaderUniform()); + blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[1].scalar"), Qt3DRender::Render::ShaderUniform()); + blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[2].scalar"), Qt3DRender::Render::ShaderUniform()); + // build name-value map + blockBuilder.buildActiveUniformNameValueMapStructHelper(backendArrayShaderData, QStringLiteral("MyBlock")); + + // THEN + QVERIFY(blockBuilder.uniforms.count() == 3); + QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 3); + + // WHEN + auto it = blockBuilder.uniforms.cbegin(); + const auto end = blockBuilder.uniforms.cend(); + + while (it != end) { + // THEN + const int nameId = Qt3DRender::Render::StringToInt::lookupId(it.key()); + QVERIFY(blockBuilder.activeUniformNamesToValue.contains(nameId)); + QCOMPARE(blockBuilder.activeUniformNamesToValue[nameId], scalarValues.value(it.key())); + ++it; + } +} + void tst_RenderViewUtils::topLevelStructValue_data() { QTest::addColumn<StructShaderData*>("shaderData"); @@ -430,6 +627,7 @@ void tst_RenderViewUtils::topLevelStructValue() QFETCH(StructShaderData *, shaderData); QFETCH(QString, blockName); QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); // WHEN initBackendShaderData(shaderData, manager.data()); @@ -441,6 +639,7 @@ void tst_RenderViewUtils::topLevelStructValue() // WHEN Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); blockBuilder.updatedPropertiesOnly = false; blockBuilder.uniforms = shaderData->buildUniformMap(blockName); const QHash<QString, QVariant> expectedValues = shaderData->buildUniformMapValues(blockName); @@ -468,10 +667,14 @@ void tst_RenderViewUtils::topLevelDynamicProperties() // GIVEN QScopedPointer<Qt3DRender::QShaderData> shaderData(new Qt3DRender::QShaderData()); QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager()); + QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D); + QScopedPointer<Qt3DRender::Render::TextureManager> textureManager(new Qt3DRender::Render::TextureManager()); // WHEN + initBackendTexture(texture.data(), textureManager.data()); shaderData->setProperty("scalar", 883.0f); shaderData->setProperty("array", QVariantList() << 454 << 350 << 383 << 427 << 552); + shaderData->setProperty("texture", QVariant::fromValue(texture.data())); initBackendShaderData(shaderData.data(), manager.data()); // THEN @@ -481,20 +684,24 @@ void tst_RenderViewUtils::topLevelDynamicProperties() // WHEN Qt3DRender::Render::UniformBlockValueBuilder blockBuilder; blockBuilder.shaderDataManager = manager.data(); + blockBuilder.textureManager = textureManager.data(); blockBuilder.updatedPropertiesOnly = false; blockBuilder.uniforms.insert(QStringLiteral("MyBlock.scalar"), Qt3DRender::Render::ShaderUniform()); blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0]"), Qt3DRender::Render::ShaderUniform()); + blockBuilder.uniforms.insert(QStringLiteral("MyBlock.texture"), Qt3DRender::Render::ShaderUniform()); // build name-value map blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock")); // THEN - QVERIFY(blockBuilder.uniforms.count() == 2); - QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 2); + QVERIFY(blockBuilder.uniforms.count() == 3); + QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 3); QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.scalar")), shaderData->property("scalar")); QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.array[0]")), shaderData->property("array")); + QCOMPARE(blockBuilder.activeUniformNamesToValue.value(Qt3DRender::Render::StringToInt::lookupId("MyBlock.texture")), + QVariant::fromValue(texture->id())); } void tst_RenderViewUtils::transformedProperties() @@ -558,6 +765,19 @@ void tst_RenderViewUtils::shouldNotifyDynamicPropertyChanges() QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); QCOMPARE(change->propertyName(), QByteArrayLiteral("scalar")); QCOMPARE(change->value().toFloat(), 883.0f); + + arbiter.events.clear(); + + // WHEN + QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D); + shaderData->setProperty("texture", QVariant::fromValue(texture.data())); + + // THEN + QCOMPARE(arbiter.events.size(), 1); + change = arbiter.events.first().dynamicCast<Qt3DCore::QDynamicPropertyUpdatedChange>(); + QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + QCOMPARE(change->propertyName(), QByteArrayLiteral("texture")); + QCOMPARE(change->value(), QVariant::fromValue(texture->id())); } QTEST_MAIN(tst_RenderViewUtils) diff --git a/tests/auto/render/scene2d/scene2d.pro b/tests/auto/render/scene2d/scene2d.pro new file mode 100644 index 000000000..aacdea3e4 --- /dev/null +++ b/tests/auto/render/scene2d/scene2d.pro @@ -0,0 +1,12 @@ +TEMPLATE = app + +TARGET = tst_scene2d + +QT += 3dcore 3dcore-private 3drender 3drender-private testlib 3dquickscene2d 3dquickscene2d-private + +CONFIG += testcase + +SOURCES += tst_scene2d.cpp + +include(../../core/common/common.pri) +include(../commons/commons.pri) diff --git a/tests/auto/render/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp new file mode 100644 index 000000000..a78ed0ab1 --- /dev/null +++ b/tests/auto/render/scene2d/tst_scene2d.cpp @@ -0,0 +1,450 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QTest> +#include <Qt3DQuickScene2D/qscene2d.h> +#include <private/qscene2d_p.h> +#include <private/scene2d_p.h> +#include <Qt3DRender/qgeometryrenderer.h> +#include <Qt3DRender/qbuffer.h> +#include <private/trianglesvisitor_p.h> +#include <private/nodemanagers_p.h> +#include <private/managers_p.h> +#include <private/geometryrenderer_p.h> +#include <private/geometryrenderermanager_p.h> +#include <private/buffermanager_p.h> +#include <Qt3DRender/qpicktriangleevent.h> +#include <private/qpickevent_p.h> +#include <Qt3DCore/qpropertyupdatedchange.h> +#include <qbackendnodetester.h> +#include "testrenderer.h" + +using namespace Qt3DRender::Quick; +using namespace Qt3DRender::Render; +using namespace Qt3DRender::Render::Quick; + +bool qFuzzyComparePointF(const QPointF& a, const QPointF& b) { + return qFuzzyCompare(a.x(), b.x()) && qFuzzyCompare(a.y(), b.y()); +} + +class TestWindow : public QQuickWindow +{ + Q_OBJECT +public: + TestWindow() + : QQuickWindow() + { + + } + + bool event(QEvent *e) Q_DECL_OVERRIDE + { + if (e->type() >= QEvent::MouseButtonPress && + e->type() <= QEvent::MouseMove) { + QMouseEvent *me = static_cast<QMouseEvent *>(e); + m_eventTypes.push_back(e->type()); + m_mousePoints.push_back(me->localPos()); + } + return QQuickWindow::event(e); + } + + bool verifyEventPos(uint index, QEvent::Type type, const QPointF& pos) + { + if (index >= unsigned(m_eventTypes.size()) || + m_eventTypes[index] != type || + !qFuzzyComparePointF(pos, m_mousePoints[index])) + return false; + return true; + } + + void clear() + { + m_eventTypes.clear(); + m_mousePoints.clear(); + } + +private: + QVector<QEvent::Type> m_eventTypes; + QVector<QPointF> m_mousePoints; +}; + +class tst_Scene2D : public Qt3DCore::QBackendNodeTester +{ + Q_OBJECT + +private Q_SLOTS: + + void checkInitialState() + { + // GIVEN + Scene2D backendScene2d; + + // THEN + QCOMPARE(backendScene2d.isEnabled(), false); + QVERIFY(backendScene2d.peerId().isNull()); + QCOMPARE(backendScene2d.m_context, nullptr); + QCOMPARE(backendScene2d.m_shareContext, nullptr); + QCOMPARE(backendScene2d.m_renderThread, nullptr); + QCOMPARE(backendScene2d.m_outputId, Qt3DCore::QNodeId()); + QCOMPARE(backendScene2d.m_initialized, false); + QCOMPARE(backendScene2d.m_renderInitialized, false); + QCOMPARE(backendScene2d.m_renderPolicy, QScene2D::Continuous); + QCOMPARE(backendScene2d.m_mouseEnabled, true); + backendScene2d.cleanup(); + } + + void checkInitializeFromPeer() + { + // GIVEN + Qt3DRender::Quick::QScene2D frontend; + TestRenderer renderer; + + { + // WHEN + QScopedPointer<Scene2D> backendScene2d(new Scene2D()); + backendScene2d->setRenderer(&renderer); + simulateInitialization(&frontend, backendScene2d.data()); + + // THEN + QCOMPARE(backendScene2d->isEnabled(), true); + QCOMPARE(backendScene2d->peerId(), frontend.id()); + QCOMPARE(backendScene2d->m_outputId, Qt3DCore::QNodeId()); + QVERIFY(backendScene2d->m_sharedObject.data() != nullptr); + QCOMPARE(backendScene2d->m_renderPolicy, QScene2D::Continuous); + QCOMPARE(backendScene2d->m_mouseEnabled, true); + backendScene2d->cleanup(); + } + { + // WHEN + QScopedPointer<Scene2D> backendScene2d(new Scene2D()); + frontend.setEnabled(false); + backendScene2d->setRenderer(&renderer); + simulateInitialization(&frontend, backendScene2d.data()); + + // THEN + QCOMPARE(backendScene2d->peerId(), frontend.id()); + QCOMPARE(backendScene2d->isEnabled(), false); + backendScene2d->cleanup(); + } + } + + void checkSceneChangeEvents() + { + // GIVEN + QScopedPointer<Scene2D> backendScene2d(new Scene2D()); + TestRenderer renderer; + QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput()); + backendScene2d->setRenderer(&renderer); + + { + // WHEN + const bool newValue = false; + const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); + change->setPropertyName("enabled"); + change->setValue(newValue); + backendScene2d->sceneChangeEvent(change); + + // THEN + QCOMPARE(backendScene2d->isEnabled(), newValue); + } + { + // WHEN + const Qt3DCore::QNodeId newValue = output.data()->id(); + const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); + change->setPropertyName("output"); + change->setValue(QVariant::fromValue(newValue)); + backendScene2d->sceneChangeEvent(change); + + // THEN + QCOMPARE(backendScene2d->m_outputId, newValue); + } + { + // WHEN + const QScene2D::RenderPolicy newValue = QScene2D::SingleShot; + const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); + change->setPropertyName("renderPolicy"); + change->setValue(QVariant::fromValue(newValue)); + backendScene2d->sceneChangeEvent(change); + + // THEN + QCOMPARE(backendScene2d->m_renderPolicy, newValue); + } + { + // WHEN + const bool newValue = false; + const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); + change->setPropertyName("mouseEnabled"); + change->setValue(newValue); + backendScene2d->sceneChangeEvent(change); + + // THEN + QCOMPARE(backendScene2d->isEnabled(), newValue); + } + + backendScene2d->cleanup(); + } + + + void testCoordinateCalculation() + { + // GIVEN + QScopedPointer<TestWindow> testWindow(new TestWindow()); + Scene2DSharedObjectPtr sharedObject(new Scene2DSharedObject(nullptr)); + QScopedPointer<Scene2D> scene2d(new Scene2D()); + QScopedPointer<NodeManagers> nodeManagers(new NodeManagers()); + Qt3DRender::QGeometry *geometry = new Qt3DRender::QGeometry(); + Qt3DRender::QGeometryRenderer *geometryRenderer = new Qt3DRender::QGeometryRenderer(); + Qt3DRender::QAttribute *positionAttribute = new Qt3DRender::QAttribute(); + Qt3DRender::QAttribute *texcoordAttribute = new Qt3DRender::QAttribute(); + Qt3DRender::QBuffer *dataBuffer =new Qt3DRender::QBuffer(); + QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity()); + entity->addComponent(geometryRenderer); + TestRenderer renderer; + renderer.setNodeManagers(nodeManagers.data()); + scene2d->setRenderer(&renderer); + scene2d->setEnabled(true); + sharedObject->m_quickWindow = testWindow.data(); + scene2d->setSharedObject(sharedObject); + testWindow->setGeometry(0,0,1024,1024); + + QByteArray data; + data.resize(sizeof(float) * 5 * 6); + float *dataPtr = reinterpret_cast<float *>(data.data()); + int i = 0; + dataPtr[i++] = -1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 0; + dataPtr[i++] = 0; + + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 0; + + dataPtr[i++] = 1.0f; + dataPtr[i++] = -1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + + dataPtr[i++] = -1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 0; + dataPtr[i++] = 0; + + dataPtr[i++] = 1.0f; + dataPtr[i++] = -1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 1.0f; + + dataPtr[i++] = -1.0f; + dataPtr[i++] = -1.0f; + dataPtr[i++] = 1.0f; + dataPtr[i++] = 0.0f; + dataPtr[i++] = 1.0f; + + dataBuffer->setData(data); + Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); + backendBuffer->setRenderer(&renderer); + backendBuffer->setManager(nodeManagers->bufferManager()); + simulateInitialization(dataBuffer, backendBuffer); + + positionAttribute->setBuffer(dataBuffer); + positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); + positionAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + positionAttribute->setVertexSize(3); + positionAttribute->setCount(6); + positionAttribute->setByteStride(sizeof(float) * 5); + positionAttribute->setByteOffset(0); + positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(positionAttribute); + + texcoordAttribute->setBuffer(dataBuffer); + texcoordAttribute->setName(Qt3DRender::QAttribute::defaultTextureCoordinateAttributeName()); + texcoordAttribute->setVertexBaseType(Qt3DRender::QAttribute::Float); + texcoordAttribute->setVertexSize(2); + texcoordAttribute->setCount(6); + texcoordAttribute->setByteStride(sizeof(float) * 5); + texcoordAttribute->setByteOffset(sizeof(float) * 3); + texcoordAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute); + geometry->addAttribute(texcoordAttribute); + + geometryRenderer->setGeometry(geometry); + geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles); + + Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource( + positionAttribute->id()); + backendAttribute->setRenderer(&renderer); + simulateInitialization(positionAttribute, backendAttribute); + + Attribute *backendTexcoordAttribute = nodeManagers->attributeManager() + ->getOrCreateResource(texcoordAttribute->id()); + backendTexcoordAttribute->setRenderer(&renderer); + simulateInitialization(texcoordAttribute, backendTexcoordAttribute); + + Geometry *backendGeometry = nodeManagers->geometryManager() + ->getOrCreateResource(geometry->id()); + backendGeometry->setRenderer(&renderer); + simulateInitialization(geometry, backendGeometry); + + GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() + ->getOrCreateResource(geometryRenderer->id()); + backendRenderer->setRenderer(&renderer); + backendRenderer->setManager(nodeManagers->geometryRendererManager()); + simulateInitialization(geometryRenderer, backendRenderer); + + Entity *backendEntity = nodeManagers->renderNodesManager()->getOrCreateResource(entity->id()); + backendEntity->setRenderer(&renderer); + backendEntity->setNodeManagers(nodeManagers.data()); + simulateInitialization(entity.data(), backendEntity); + +#define PICK_TRIANGLE(tri, v0, v1, v2, uvw) \ + new Qt3DRender::QPickTriangleEvent(QPointF(), QVector3D(), QVector3D(), 0.0f, \ + tri, v0, v1, v2, Qt3DRender::QPickEvent::LeftButton, Qt::LeftButton, 0, uvw) + + { + // WHEN + QVector3D uvw(1.0, 0.0f, 0.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(0,1024))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.0, 1.0f, 0.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(1024,1024))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.0, 0.0f, 1.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(1024,0))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(1.0, 0.0f, 0.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(0,1024))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.0, 1.0f, 0.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(1024,0))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.0, 0.0f, 1.0f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(0,0))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.5f, 0.25f, 0.25f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(0, 0, 1, 2, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(512.0f, 768.0f))); + testWindow->clear(); + } + + { + // WHEN + QVector3D uvw(0.875f, 0.09375f, 0.03125f); + Qt3DRender::QPickEventPtr ev = Qt3DRender::QPickEventPtr(PICK_TRIANGLE(1, 3, 4, 5, uvw)); + Qt3DRender::QPickEventPrivate::get(ev.data())->m_entity = entity->id(); + scene2d->handlePickEvent(QEvent::MouseButtonPress, ev); + + QCoreApplication::processEvents(); + + // THEN + QVERIFY(testWindow->verifyEventPos(0, QEvent::MouseButtonPress, QPointF(96.0f, 896.0f))); + testWindow->clear(); + } + } +}; + +QTEST_MAIN(tst_Scene2D) + +#include "tst_scene2d.moc" diff --git a/tests/auto/render/sceneloader/tst_sceneloader.cpp b/tests/auto/render/sceneloader/tst_sceneloader.cpp index edd6fabda..975c2c892 100644 --- a/tests/auto/render/sceneloader/tst_sceneloader.cpp +++ b/tests/auto/render/sceneloader/tst_sceneloader.cpp @@ -79,7 +79,7 @@ private Q_SLOTS: { // GIVEN Qt3DRender::QSceneLoader frontendSceneLoader; - frontendSceneLoader.setSource(QUrl(QStringLiteral("CorvetteMuseum"))); + frontendSceneLoader.setSource(QUrl(QStringLiteral("file:///CorvetteMuseum"))); Qt3DRender::Render::Scene sceneLoader; Qt3DRender::Render::SceneManager sceneManager; @@ -109,7 +109,7 @@ private Q_SLOTS: // WHEN Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - const QUrl newUrl(QStringLiteral("Bownling_Green_KY")); + const QUrl newUrl(QStringLiteral("file:///Bownling_Green_KY")); updateChange->setValue(newUrl); updateChange->setPropertyName("source"); sceneLoader.sceneChangeEvent(updateChange); @@ -147,7 +147,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); QCOMPARE(change->propertyName(), "scene"); QCOMPARE(change->value().value<Qt3DCore::QEntity *>(), &subtree); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); } @@ -170,7 +169,6 @@ private Q_SLOTS: QCOMPARE(arbiter.events.count(), 1); QCOMPARE(change->propertyName(), "status"); QCOMPARE(change->value().value<Qt3DRender::QSceneLoader::Status>(), Qt3DRender::QSceneLoader::Ready); - QCOMPARE(Qt3DCore::QPropertyUpdatedChangeBasePrivate::get(change.data())->m_isFinal, true); arbiter.events.clear(); } diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp index 95576afe0..f6ed41a8b 100644 --- a/tests/auto/render/shader/tst_shader.cpp +++ b/tests/auto/render/shader/tst_shader.cpp @@ -81,6 +81,7 @@ void tst_RenderShader::hasCoherentInitialState() QVERIFY(shader->uniforms().isEmpty()); QVERIFY(shader->attributes().isEmpty()); QVERIFY(shader->uniformBlocks().isEmpty()); + QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady); } void tst_RenderShader::matchesFrontendPeer() @@ -114,6 +115,7 @@ void tst_RenderShader::cleanupLeavesACoherentState() QVERIFY(shader->uniforms().isEmpty()); QVERIFY(shader->attributes().isEmpty()); QVERIFY(shader->uniformBlocks().isEmpty()); + QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady); } QTEST_APPLESS_MAIN(tst_RenderShader) diff --git a/tests/auto/render/texturedatamanager/tst_texturedatamanager.cpp b/tests/auto/render/texturedatamanager/tst_texturedatamanager.cpp index b76495d93..5ba43aedc 100644 --- a/tests/auto/render/texturedatamanager/tst_texturedatamanager.cpp +++ b/tests/auto/render/texturedatamanager/tst_texturedatamanager.cpp @@ -58,7 +58,9 @@ class FakeData public: explicit FakeData(int value) : m_value(value) - {} + { + Q_UNUSED(m_value); + } private: int m_value; diff --git a/tests/auto/render/textures/tst_textures.cpp b/tests/auto/render/textures/tst_textures.cpp index 9246bba34..82c638275 100644 --- a/tests/auto/render/textures/tst_textures.cpp +++ b/tests/auto/render/textures/tst_textures.cpp @@ -52,12 +52,12 @@ class TestImageDataGenerator : public Qt3DRender::QTextureImageDataGenerator public: TestImageDataGenerator(int id) : m_id(id) {} - Qt3DRender::QTextureImageDataPtr operator ()() { + Qt3DRender::QTextureImageDataPtr operator ()() Q_DECL_OVERRIDE { return Qt3DRender::QTextureImageDataPtr::create(); } - bool operator ==(const Qt3DRender::QTextureImageDataGenerator &other) const { - const TestImageDataGenerator *otherFunctor = functor_cast<TestImageDataGenerator>(&other); + bool operator ==(const Qt3DRender::QTextureImageDataGenerator &other) const Q_DECL_OVERRIDE { + const TestImageDataGenerator *otherFunctor = Qt3DRender::functor_cast<TestImageDataGenerator>(&other); return (otherFunctor != Q_NULLPTR && otherFunctor->m_id == m_id); } @@ -73,12 +73,12 @@ class TestTextureGenerator : public Qt3DRender::QTextureGenerator public: TestTextureGenerator(int id) : m_id(id) {} - Qt3DRender::QTextureDataPtr operator ()() { + Qt3DRender::QTextureDataPtr operator ()() Q_DECL_OVERRIDE { return Qt3DRender::QTextureDataPtr::create(); } - bool operator ==(const Qt3DRender::QTextureGenerator &other) const { - const TestTextureGenerator *otherFunctor = functor_cast<TestTextureGenerator>(&other); + bool operator ==(const Qt3DRender::QTextureGenerator &other) const Q_DECL_OVERRIDE { + const TestTextureGenerator *otherFunctor = Qt3DRender::functor_cast<TestTextureGenerator>(&other); return (otherFunctor != Q_NULLPTR && otherFunctor->m_id == m_id); } diff --git a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml index 20585b5de..3b21b08ba 100644 --- a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml +++ b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml @@ -48,9 +48,9 @@ ** ****************************************************************************/ -import Qt3D.Core 2.0 -import Qt3D.Render 2.0 -import Qt3D.Extras 2.0 +import Qt3D.Core 2.9 +import Qt3D.Render 2.9 +import Qt3D.Extras 2.9 import QtQuick.Window 2.0 Entity { diff --git a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml index d3e766021..59ccdd27f 100644 --- a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml +++ b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml @@ -48,9 +48,9 @@ ** ****************************************************************************/ -import Qt3D.Core 2.0 -import Qt3D.Render 2.0 -import Qt3D.Extras 2.0 +import Qt3D.Core 2.9 +import Qt3D.Render 2.9 +import Qt3D.Extras 2.9 import QtQuick.Window 2.0 Entity { diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp index 9b53d1f65..c076aa21e 100644 --- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp +++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp @@ -165,7 +165,7 @@ private Q_SLOTS: Qt3DRender::Render::ShaderData *backendShaderData = collection.backendShaderData.first(); // THEN - QCOMPARE(backendShaderData->properties().size(), 2); + QCOMPARE(backendShaderData->properties().size(), 3); QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePosition"))); QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePositionTransformed"))); @@ -205,7 +205,7 @@ private Q_SLOTS: Qt3DRender::Render::ShaderData *backendShaderData = collection.backendShaderData.first(); // THEN - QCOMPARE(backendShaderData->properties().size(), 2); + QCOMPARE(backendShaderData->properties().size(), 3); QVERIFY(backendShaderData->properties().contains(QLatin1String("position"))); QVERIFY(backendShaderData->properties().contains(QLatin1String("positionTransformed"))); diff --git a/tests/auto/render/vsyncframeadvanceservice/BLACKLIST b/tests/auto/render/vsyncframeadvanceservice/BLACKLIST new file mode 100644 index 000000000..34dccc8fe --- /dev/null +++ b/tests/auto/render/vsyncframeadvanceservice/BLACKLIST @@ -0,0 +1,2 @@ +[checkSynchronisation] +opensuse-42.1 |