diff options
Diffstat (limited to 'tests/auto/render')
62 files changed, 1206 insertions, 1446 deletions
diff --git a/tests/auto/render/armature/tst_armature.cpp b/tests/auto/render/armature/tst_armature.cpp index 2c481db7a..4f9380a3b 100644 --- a/tests/auto/render/armature/tst_armature.cpp +++ b/tests/auto/render/armature/tst_armature.cpp @@ -56,7 +56,7 @@ private Q_SLOTS: armature.setSkeleton(skeleton); // WHEN - simulateInitialization(&armature, &backendArmature); + simulateInitializationSync(&armature, &backendArmature); // THEN QCOMPARE(backendArmature.peerId(), armature.id()); @@ -80,7 +80,7 @@ private Q_SLOTS: armature.setSkeleton(skeleton); // WHEN - simulateInitialization(&armature, &backendArmature); + simulateInitializationSync(&armature, &backendArmature); backendArmature.cleanup(); // THEN @@ -91,24 +91,21 @@ private Q_SLOTS: void checkPropertyChanges() { // GIVEN + QArmature armature; Armature backendArmature; - Qt3DCore::QPropertyUpdatedChangePtr updateChange; + simulateInitializationSync(&armature, &backendArmature); // WHEN - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("enabled"); - updateChange->setValue(true); - backendArmature.sceneChangeEvent(updateChange); + armature.setEnabled(false); + backendArmature.syncFromFrontEnd(&armature, false); // THEN - QCOMPARE(backendArmature.isEnabled(), true); + QCOMPARE(backendArmature.isEnabled(), false); // WHEN auto newSkeleton = new QSkeleton(); - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("skeleton"); - updateChange->setValue(QVariant::fromValue(newSkeleton->id())); - backendArmature.sceneChangeEvent(updateChange); + armature.setSkeleton(newSkeleton); + backendArmature.syncFromFrontEnd(&armature, false); // THEN QCOMPARE(backendArmature.skeletonId(), newSkeleton->id()); diff --git a/tests/auto/render/attribute/tst_attribute.cpp b/tests/auto/render/attribute/tst_attribute.cpp index e0f6f6b5c..12b99b37d 100644 --- a/tests/auto/render/attribute/tst_attribute.cpp +++ b/tests/auto/render/attribute/tst_attribute.cpp @@ -36,12 +36,15 @@ class tst_Attribute : public Qt3DCore::QBackendNodeTester { Q_OBJECT + private Q_SLOTS: void checkPeerPropertyMirroring() { // GIVEN + TestRenderer renderer; Qt3DRender::Render::Attribute renderAttribute; + renderAttribute.setRenderer(&renderer); Qt3DRender::QAttribute attribute; attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute); @@ -59,7 +62,7 @@ private Q_SLOTS: attribute.setBuffer(&buffer); // WHEN - simulateInitialization(&attribute, &renderAttribute); + simulateInitializationSync(&attribute, &renderAttribute); // THEN QCOMPARE(renderAttribute.peerId(), attribute.id()); @@ -111,7 +114,7 @@ private Q_SLOTS: attribute.setBuffer(&buffer); // WHEN - simulateInitialization(&attribute, &renderAttribute); + simulateInitializationSync(&attribute, &renderAttribute); renderAttribute.cleanup(); // THEN @@ -130,17 +133,20 @@ private Q_SLOTS: void checkPropertyChanges() { // GIVEN + Qt3DRender::QAttribute attribute; TestRenderer renderer; Qt3DRender::Render::Attribute renderAttribute; renderAttribute.setRenderer(&renderer); + simulateInitializationSync(&attribute, &renderAttribute); + renderAttribute.cleanup(); + renderer.resetDirty(); QVERIFY(!renderAttribute.isDirty()); + QVERIFY(!renderer.dirtyBits()); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::Int)); - updateChange->setPropertyName("vertexBaseType"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setVertexBaseType(Qt3DRender::QAttribute::Int); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.vertexBaseType(), Qt3DRender::QAttribute::Int); @@ -153,10 +159,8 @@ private Q_SLOTS: QVERIFY(!renderer.dirtyBits()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(3); - updateChange->setPropertyName("vertexSize"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setVertexSize(3); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.vertexSize(), 3U); @@ -168,10 +172,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::IndexAttribute)); - updateChange->setPropertyName("attributeType"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::IndexAttribute); @@ -183,10 +185,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::DrawIndirectAttribute)); - updateChange->setPropertyName("attributeType"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setAttributeType(Qt3DRender::QAttribute::DrawIndirectAttribute); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::DrawIndirectAttribute); @@ -198,10 +198,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(1340); - updateChange->setPropertyName("count"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setCount(1340); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.count(), 1340U); @@ -213,10 +211,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QStringLiteral("L88")); - updateChange->setPropertyName("name"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setName(QStringLiteral("L88")); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.name(), QStringLiteral("L88")); @@ -228,10 +224,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(555); - updateChange->setPropertyName("byteOffset"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setByteOffset(555U); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.byteOffset(), 555U); @@ -243,10 +237,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(454); - updateChange->setPropertyName("byteStride"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setByteStride(454); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.byteStride(), 454U); @@ -258,10 +250,8 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(1450); - updateChange->setPropertyName("divisor"); - renderAttribute.sceneChangeEvent(updateChange); + attribute.setDivisor(1450); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN QCOMPARE(renderAttribute.divisor(), 1450U); @@ -273,14 +263,12 @@ private Q_SLOTS: QVERIFY(!renderAttribute.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - Qt3DCore::QNodeId bufferId = Qt3DCore::QNodeId::createId(); - updateChange->setValue(QVariant::fromValue(bufferId)); - updateChange->setPropertyName("buffer"); - renderAttribute.sceneChangeEvent(updateChange); + auto buffer = new Qt3DRender::QBuffer(); + attribute.setBuffer(buffer); + renderAttribute.syncFromFrontEnd(&attribute, false); // THEN - QCOMPARE(renderAttribute.bufferId(), bufferId); + QCOMPARE(renderAttribute.bufferId(), buffer->id()); QVERIFY(renderAttribute.isDirty()); QVERIFY(renderer.dirtyBits() != 0); diff --git a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp index b10c2e88e..f7a6ce214 100644 --- a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp +++ b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp @@ -78,7 +78,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer; backendBlitFramebuffer.setRenderer(&renderer); - simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer); + simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer); // THEN QCOMPARE(backendBlitFramebuffer.isEnabled(), true); @@ -98,7 +98,7 @@ private Q_SLOTS: Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer; backendBlitFramebuffer.setRenderer(&renderer); blitFramebuffer.setEnabled(false); - simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer); + simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer); // THEN QCOMPARE(backendBlitFramebuffer.peerId(), blitFramebuffer.id()); @@ -111,98 +111,84 @@ private Q_SLOTS: { // GIVEN Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer; + Qt3DRender::QBlitFramebuffer blitFramebuffer; TestRenderer renderer; backendBlitFramebuffer.setRenderer(&renderer); + simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer); { - // WHEN - const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendBlitFramebuffer.sceneChangeEvent(change); - - // THEN + // WHEN + const bool newValue = false; + blitFramebuffer.setEnabled(newValue); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); + + // THEN QCOMPARE(backendBlitFramebuffer.isEnabled(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN - const Qt3DRender::QRenderTarget sourceRenderTarget; - const Qt3DCore::QNodeId newValue = sourceRenderTarget.id(); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("sourceRenderTarget"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); - - // THEN - QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), newValue); + // WHEN + Qt3DRender::QRenderTarget sourceRenderTarget; + blitFramebuffer.setSource(&sourceRenderTarget); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); + + // THEN + QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), sourceRenderTarget.id()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN - const Qt3DRender::QRenderTarget destinationRenderTarget; - const Qt3DCore::QNodeId newValue = destinationRenderTarget.id(); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("destinationRenderTarget"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); - - // THEN - QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), newValue); + // WHEN + Qt3DRender::QRenderTarget destinationRenderTarget; + blitFramebuffer.setDestination(&destinationRenderTarget); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); + + // THEN + QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), destinationRenderTarget.id()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN + // WHEN const auto newValue = QRect(0,0,1,1); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("sourceRect"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); + blitFramebuffer.setSourceRect(newValue); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); - // THEN + // THEN QCOMPARE(backendBlitFramebuffer.sourceRect(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN + // WHEN const auto newValue = QRect(0,0,1,1); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("destinationRect"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); + blitFramebuffer.setDestinationRect(newValue); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); - // THEN + // THEN QCOMPARE(backendBlitFramebuffer.destinationRect(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN + // WHEN const auto newValue = Qt3DRender::QRenderTargetOutput::Color1; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("sourceAttachmentPoint"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); + blitFramebuffer.setSourceAttachmentPoint(newValue); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); - // THEN + // THEN QCOMPARE(backendBlitFramebuffer.sourceAttachmentPoint(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } { - // WHEN + // WHEN const auto newValue = Qt3DRender::QRenderTargetOutput::Color1; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("destinationAttachmentPoint"); - change->setValue(QVariant::fromValue(newValue)); - backendBlitFramebuffer.sceneChangeEvent(change); + blitFramebuffer.setDestinationAttachmentPoint(newValue); + backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false); - // THEN + // THEN QCOMPARE(backendBlitFramebuffer.destinationAttachmentPoint(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp index 5f4f26d50..80298780a 100644 --- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp +++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp @@ -55,7 +55,6 @@ #include <Qt3DRender/private/calcboundingvolumejob_p.h> #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h> #include <Qt3DRender/private/loadbufferjob_p.h> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DRender/private/buffermanager_p.h> #include <Qt3DRender/private/geometryrenderermanager_p.h> #include <Qt3DRender/private/sphere_p.h> @@ -96,6 +95,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -106,7 +122,8 @@ public: QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + const QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges = nodeTreeChangesForNodes(nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChanges); Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); @@ -139,10 +156,6 @@ namespace { void runRequiredJobs(Qt3DRender::TestAspect *test) { - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(test->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; updateWorldTransform.setRoot(test->sceneRoot()); updateWorldTransform.setManagers(test->nodeManagers()); @@ -296,13 +309,13 @@ private Q_SLOTS: Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id()); vbufferBackend->setRenderer(test->renderer()); vbufferBackend->setManager(test->nodeManagers()->bufferManager()); - simulateInitialization(vbuffer, vbufferBackend); + simulateInitializationSync(vbuffer, vbufferBackend); ibuffer->setData(idata); Qt3DRender::Render::Buffer *ibufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(ibuffer->id()); ibufferBackend->setRenderer(test->renderer()); ibufferBackend->setManager(test->nodeManagers()->bufferManager()); - simulateInitialization(ibuffer, ibufferBackend); + simulateInitializationSync(ibuffer, ibufferBackend); Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry; for (int i = 0; i < 2; ++i) @@ -336,23 +349,23 @@ private Q_SLOTS: Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id()); attr0Backend->setRenderer(test->renderer()); - simulateInitialization(attrs[0], attr0Backend); + simulateInitializationSync(attrs[0], attr0Backend); Qt3DRender::Render::Attribute *attr1Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[1]->id()); attr1Backend->setRenderer(test->renderer()); - simulateInitialization(attrs[1], attr1Backend); + simulateInitializationSync(attrs[1], attr1Backend); Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id()); gBackend->setRenderer(test->renderer()); - simulateInitialization(g, gBackend); + simulateInitializationSync(g, gBackend); Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id()); grBackend->setRenderer(test->renderer()); grBackend->setManager(test->nodeManagers()->geometryRendererManager()); - simulateInitialization(gr, grBackend); + simulateInitializationSync(gr, grBackend); Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id()); entityBackend->setRenderer(test->renderer()); - simulateInitialization(entity.data(), entityBackend); + simulateInitializationSync(entity.data(), entityBackend); Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume; calcBVolume.setManagers(test->nodeManagers()); @@ -364,10 +377,10 @@ private Q_SLOTS: qDebug() << radius << center; // truncate and compare integers only - QVERIFY(int(radius) == int(expectedRadius)); - QVERIFY(int(center.x()) == int(expectedCenter.x())); - QVERIFY(int(center.y()) == int(expectedCenter.y())); - QVERIFY(int(center.z()) == int(expectedCenter.z())); + QCOMPARE(int(radius), int(expectedRadius)); + QCOMPARE(int(center.x()), int(expectedCenter.x())); + QCOMPARE(int(center.y()), int(expectedCenter.y())); + QCOMPARE(int(center.z()), int(expectedCenter.z())); } void checkCustomPackedGeometry() @@ -408,7 +421,7 @@ private Q_SLOTS: Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id()); vbufferBackend->setRenderer(test->renderer()); vbufferBackend->setManager(test->nodeManagers()->bufferManager()); - simulateInitialization(vbuffer, vbufferBackend); + simulateInitializationSync(vbuffer, vbufferBackend); Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry; g->addAttribute(new Qt3DRender::QAttribute); @@ -430,20 +443,20 @@ private Q_SLOTS: Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id()); attr0Backend->setRenderer(test->renderer()); - simulateInitialization(attrs[0], attr0Backend); + simulateInitializationSync(attrs[0], attr0Backend); Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id()); gBackend->setRenderer(test->renderer()); - simulateInitialization(g, gBackend); + simulateInitializationSync(g, gBackend); Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id()); grBackend->setRenderer(test->renderer()); grBackend->setManager(test->nodeManagers()->geometryRendererManager()); - simulateInitialization(gr, grBackend); + simulateInitializationSync(gr, grBackend); Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id()); entityBackend->setRenderer(test->renderer()); - simulateInitialization(entity.data(), entityBackend); + simulateInitializationSync(entity.data(), entityBackend); Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume; calcBVolume.setManagers(test->nodeManagers()); diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp index da853d4e9..1487d3728 100644 --- a/tests/auto/render/buffer/tst_buffer.cpp +++ b/tests/auto/render/buffer/tst_buffer.cpp @@ -65,6 +65,7 @@ private: class tst_RenderBuffer : public Qt3DCore::QBackendNodeTester { Q_OBJECT + private Q_SLOTS: void checkPeerPropertyMirroring() @@ -82,7 +83,7 @@ private Q_SLOTS: // WHEN renderBuffer.setRenderer(&renderer); renderBuffer.setManager(&bufferManager); - simulateInitialization(&buffer, &renderBuffer); + simulateInitializationSync(&buffer, &renderBuffer); // THEN QCOMPARE(renderBuffer.peerId(), buffer.id()); @@ -98,170 +99,154 @@ private Q_SLOTS: void checkInitialAndCleanedUpState() { // GIVEN - Qt3DRender::Render::Buffer renderBuffer; + Qt3DRender::Render::Buffer backendBuffer; Qt3DRender::Render::BufferManager bufferManager; TestRenderer renderer; // THEN - QCOMPARE(renderBuffer.isDirty(), false); - QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw); - QVERIFY(renderBuffer.data().isEmpty()); - QVERIFY(renderBuffer.peerId().isNull()); - QVERIFY(renderBuffer.dataGenerator().isNull()); - QVERIFY(renderBuffer.pendingBufferUpdates().empty()); + QCOMPARE(backendBuffer.isDirty(), false); + QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw); + QVERIFY(backendBuffer.data().isEmpty()); + QVERIFY(backendBuffer.peerId().isNull()); + QVERIFY(backendBuffer.dataGenerator().isNull()); + QVERIFY(backendBuffer.pendingBufferUpdates().empty()); // GIVEN - Qt3DRender::QBuffer buffer; - buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy); - buffer.setData(QByteArrayLiteral("C7")); - buffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73))); + Qt3DRender::QBuffer frontendBuffer; + frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicCopy); + frontendBuffer.setData(QByteArrayLiteral("C7KR4")); + frontendBuffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73))); // WHEN - renderBuffer.setManager(&bufferManager); - renderBuffer.setRenderer(&renderer); - simulateInitialization(&buffer, &renderBuffer); + backendBuffer.setManager(&bufferManager); + backendBuffer.setRenderer(&renderer); + simulateInitializationSync(&frontendBuffer, &backendBuffer); - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - Qt3DRender::QBufferUpdate updateData; - updateData.offset = 2; - updateData.data = QByteArrayLiteral("LS5"); - updateChange->setValue(QVariant::fromValue(updateData)); - updateChange->setPropertyName("updateData"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.updateData(2, QByteArrayLiteral("LS5")); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::DynamicCopy); - QCOMPARE(renderBuffer.isDirty(), true); - QCOMPARE(renderBuffer.data(), QByteArrayLiteral("C7LS5")); - QVERIFY(!renderBuffer.dataGenerator().isNull()); - QVERIFY(!renderBuffer.pendingBufferUpdates().empty()); + QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::DynamicCopy); + QCOMPARE(backendBuffer.isDirty(), true); + QCOMPARE(backendBuffer.data(), QByteArrayLiteral("C7LS5")); + QVERIFY(!backendBuffer.dataGenerator().isNull()); + QVERIFY(!backendBuffer.pendingBufferUpdates().empty()); // WHEN - renderBuffer.cleanup(); + backendBuffer.cleanup(); // THEN - QCOMPARE(renderBuffer.isDirty(), false); - QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw); - QVERIFY(renderBuffer.data().isEmpty()); - QVERIFY(renderBuffer.dataGenerator().isNull()); - QVERIFY(renderBuffer.pendingBufferUpdates().empty()); + QCOMPARE(backendBuffer.isDirty(), false); + QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw); + QVERIFY(backendBuffer.data().isEmpty()); + QVERIFY(backendBuffer.dataGenerator().isNull()); + QVERIFY(backendBuffer.pendingBufferUpdates().empty()); } void checkPropertyChanges() { // GIVEN TestRenderer renderer; - Qt3DRender::Render::Buffer renderBuffer; - renderBuffer.setRenderer(&renderer); + Qt3DRender::QBuffer frontendBuffer; + Qt3DRender::Render::Buffer backendBuffer; + backendBuffer.setRenderer(&renderer); + simulateInitializationSync(&frontendBuffer, &backendBuffer); // THEN - QVERIFY(renderBuffer.data().isEmpty()); - QVERIFY(renderBuffer.usage() != Qt3DRender::QBuffer::DynamicRead); - QVERIFY(!renderBuffer.isDirty()); - QVERIFY(!(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty)); + QVERIFY(backendBuffer.data().isEmpty()); + QVERIFY(backendBuffer.usage() != Qt3DRender::QBuffer::DynamicRead); + QVERIFY(!backendBuffer.isDirty()); + QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(static_cast<int>(Qt3DRender::QBuffer::DynamicRead)); - updateChange->setPropertyName("usage"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicRead); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::DynamicRead); - QVERIFY(renderBuffer.isDirty()); + QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::DynamicRead); + QVERIFY(backendBuffer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderBuffer.unsetDirty(); - QVERIFY(!renderBuffer.isDirty()); + backendBuffer.unsetDirty(); + QVERIFY(!backendBuffer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QByteArrayLiteral("LS9")); - updateChange->setPropertyName("data"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.setData(QByteArrayLiteral("LS9SL")); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QCOMPARE(renderBuffer.data(), QByteArrayLiteral("LS9")); - QVERIFY(renderBuffer.isDirty()); - QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1); - QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1); + QCOMPARE(backendBuffer.data(), QByteArrayLiteral("LS9SL")); + QVERIFY(backendBuffer.isDirty()); + QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1); + QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1); - renderBuffer.pendingBufferUpdates().clear(); + backendBuffer.pendingBufferUpdates().clear(); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderBuffer.unsetDirty(); - QVERIFY(!renderBuffer.isDirty()); + backendBuffer.unsetDirty(); + QVERIFY(!backendBuffer.isDirty()); // WHEN Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355)); - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(functor)); - updateChange->setPropertyName("dataGenerator"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.setDataGenerator(functor); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QCOMPARE(renderBuffer.dataGenerator(), functor); - QVERIFY(renderBuffer.isDirty()); + QCOMPARE(backendBuffer.dataGenerator(), functor); + QVERIFY(backendBuffer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderBuffer.unsetDirty(); - QVERIFY(!renderBuffer.isDirty()); + backendBuffer.unsetDirty(); + QVERIFY(!backendBuffer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(true); - updateChange->setPropertyName("syncData"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.setSyncData(true); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QCOMPARE(renderBuffer.isSyncData(), true); - QVERIFY(!renderBuffer.isDirty()); + QCOMPARE(backendBuffer.isSyncData(), true); + QVERIFY(!backendBuffer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); // WHEN TestArbiter arbiter; - Qt3DCore::QBackendNodePrivate::get(&renderBuffer)->setArbiter(&arbiter); - renderBuffer.executeFunctor(); + Qt3DCore::QBackendNodePrivate::get(&backendBuffer)->setArbiter(&arbiter); + backendBuffer.executeFunctor(); // THEN QCOMPARE(arbiter.events.count(), 1); Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); QCOMPARE(change->propertyName(), "data"); QCOMPARE(change->value().toByteArray(), QByteArrayLiteral("454")); - QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1); - QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1); + QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1); + QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1); arbiter.events.clear(); - renderBuffer.pendingBufferUpdates().clear(); + backendBuffer.pendingBufferUpdates().clear(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - Qt3DRender::QBufferUpdate updateData; - updateData.offset = 2; - updateData.data = QByteArrayLiteral("LS5"); - updateChange->setValue(QVariant::fromValue(updateData)); - updateChange->setPropertyName("updateData"); - renderBuffer.sceneChangeEvent(updateChange); + frontendBuffer.updateData(2, QByteArrayLiteral("LS5")); + backendBuffer.syncFromFrontEnd(&frontendBuffer, false); // THEN - QVERIFY(!renderBuffer.pendingBufferUpdates().empty()); - QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, 2); - QVERIFY(renderBuffer.isDirty()); + QVERIFY(!backendBuffer.pendingBufferUpdates().empty()); + QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, 2); + QVERIFY(backendBuffer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderBuffer.unsetDirty(); - QVERIFY(!renderBuffer.isDirty()); + backendBuffer.unsetDirty(); + QVERIFY(!backendBuffer.isDirty()); } void checkBufferManagerReferenceCount() @@ -275,7 +260,7 @@ private Q_SLOTS: // WHEN renderBuffer.setRenderer(&renderer); renderBuffer.setManager(&bufferManager); - simulateInitialization(&buffer, &renderBuffer); + simulateInitializationSync(&buffer, &renderBuffer); // THEN QVERIFY(bufferManager.takeBuffersToRelease().empty()); @@ -305,7 +290,7 @@ private Q_SLOTS: QCOMPARE(renderer.dirtyBits(), 0); // WHEN - simulateInitialization(&buffer, &renderBuffer); + simulateInitializationSync(&buffer, &renderBuffer); // THEN QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::BuffersDirty); diff --git a/tests/auto/render/commons/testaspect.cpp b/tests/auto/render/commons/testaspect.cpp index 8be6a7833..87ffc56d7 100644 --- a/tests/auto/render/commons/testaspect.cpp +++ b/tests/auto/render/commons/testaspect.cpp @@ -37,6 +37,7 @@ #include "testaspect.h" #include <Qt3DCore/private/qnodevisitor_p.h> #include <Qt3DCore/private/qnode_p.h> +#include <Qt3DCore/private/qaspectmanager_p.h> QT_BEGIN_NAMESPACE @@ -76,7 +77,12 @@ TestAspect::TestAspect(Qt3DCore::QNode *root) const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); for (Qt3DCore::QNode *node : nodes) - d_func()->createBackendNode(node); + d_func()->createBackendNode({ + node->id(), + Qt3DCore::QNodePrivate::get(node)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + node + }); } TestAspect::~TestAspect() diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h index dbe69ace5..8d27998a0 100644 --- a/tests/auto/render/commons/testrenderer.h +++ b/tests/auto/render/commons/testrenderer.h @@ -63,7 +63,7 @@ public: Qt3DCore::QAspectJobPtr rayCastingJob() override { return Qt3DCore::QAspectJobPtr(); } Qt3DCore::QAspectJobPtr syncLoadingJobs() override { return Qt3DCore::QAspectJobPtr(); } Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() override { return Qt3DCore::QAspectJobPtr(); } - void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Qt3DRender::Render::Entity *root) override { Q_UNUSED(factory); Q_UNUSED(root); } + void setSceneRoot(Qt3DRender::Render::Entity *root) override { Q_UNUSED(root); } Qt3DRender::Render::Entity *sceneRoot() const override { return nullptr; } Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const override { return nullptr; } Qt3DCore::QAbstractFrameAdvanceService *frameAdvanceService() const override { return nullptr; } diff --git a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp index afb18fe55..417684245 100644 --- a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp +++ b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp @@ -101,7 +101,7 @@ private Q_SLOTS: ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN bool ret = reader.setGeometry(backendRenderer, QString("")); @@ -149,7 +149,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -167,18 +167,18 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager() ->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager() ->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN bool ret = reader.setGeometry(backendRenderer, @@ -232,7 +232,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -250,18 +250,18 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager() ->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager() ->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN bool ret = reader.setGeometry(backendRenderer, @@ -326,7 +326,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -344,18 +344,18 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager() ->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager() ->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN bool ret = reader.setGeometry(backendRenderer, @@ -415,7 +415,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -443,23 +443,23 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource( positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendTexcoordAttribute = nodeManagers->attributeManager() ->getOrCreateResource(texcoordAttribute->id()); backendTexcoordAttribute->setRenderer(&renderer); - simulateInitialization(texcoordAttribute.data(), backendTexcoordAttribute); + simulateInitializationSync(texcoordAttribute.data(), backendTexcoordAttribute); Geometry *backendGeometry = nodeManagers->geometryManager() ->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN bool ret = reader.setGeometry(backendRenderer, diff --git a/tests/auto/render/effect/tst_effect.cpp b/tests/auto/render/effect/tst_effect.cpp index 30df242f4..cb2ca41e1 100644 --- a/tests/auto/render/effect/tst_effect.cpp +++ b/tests/auto/render/effect/tst_effect.cpp @@ -72,7 +72,7 @@ private Q_SLOTS: Qt3DRender::QParameter parameter; effect.addTechnique(&technique); effect.addParameter(¶meter); - simulateInitialization(&effect, &backendEffect); + simulateInitializationSync(&effect, &backendEffect); } backendEffect.cleanup(); @@ -95,7 +95,7 @@ private Q_SLOTS: { // WHEN Qt3DRender::Render::Effect backendEffect; - simulateInitialization(&effect, &backendEffect); + simulateInitializationSync(&effect, &backendEffect); // THEN QCOMPARE(backendEffect.isEnabled(), true); @@ -109,7 +109,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::Effect backendEffect; effect.setEnabled(false); - simulateInitialization(&effect, &backendEffect); + simulateInitializationSync(&effect, &backendEffect); // THEN QCOMPARE(backendEffect.peerId(), effect.id()); @@ -120,17 +120,17 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN + Qt3DRender::QEffect effect; Qt3DRender::Render::Effect backendEffect; TestRenderer renderer; backendEffect.setRenderer(&renderer); + simulateInitializationSync(&effect, &backendEffect); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendEffect.sceneChangeEvent(change); + effect.setEnabled(newValue); + backendEffect.syncFromFrontEnd(&effect, false); // THEN QCOMPARE(backendEffect.isEnabled(), newValue); @@ -139,9 +139,8 @@ private Q_SLOTS: Qt3DRender::QTechnique technique; { // WHEN - const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &technique); - change->setPropertyName("technique"); - backendEffect.sceneChangeEvent(change); + effect.addTechnique(&technique); + backendEffect.syncFromFrontEnd(&effect, false); // THEN QCOMPARE(backendEffect.techniques().size(), 1); @@ -149,9 +148,8 @@ private Q_SLOTS: } { // WHEN - const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &technique); - change->setPropertyName("technique"); - backendEffect.sceneChangeEvent(change); + effect.removeTechnique(&technique); + backendEffect.syncFromFrontEnd(&effect, false); // THEN QCOMPARE(backendEffect.techniques().size(), 0); @@ -162,9 +160,8 @@ private Q_SLOTS: { // WHEN - const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), ¶meter); - change->setPropertyName("parameter"); - backendEffect.sceneChangeEvent(change); + effect.addParameter(¶meter); + backendEffect.syncFromFrontEnd(&effect, false); // THEN QCOMPARE(backendEffect.parameters().size(), 1); @@ -172,9 +169,8 @@ private Q_SLOTS: } { // WHEN - const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), ¶meter); - change->setPropertyName("parameter"); - backendEffect.sceneChangeEvent(change); + effect.removeParameter(¶meter); + backendEffect.syncFromFrontEnd(&effect, false); // THEN QCOMPARE(backendEffect.parameters().size(), 0); diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp index 08d08404c..463fbbb79 100644 --- a/tests/auto/render/entity/tst_entity.cpp +++ b/tests/auto/render/entity/tst_entity.cpp @@ -182,7 +182,6 @@ private slots: entity.cleanup(); // THEN - QVERIFY(entity.parentEntityId().isNull()); QVERIFY(entity.componentUuid<Transform>().isNull()); QVERIFY(entity.componentUuid<CameraLens>().isNull()); QVERIFY(entity.componentUuid<Material>().isNull()); @@ -201,29 +200,18 @@ private slots: QVERIFY(!containsAll); } - void checkRebuildingEntityHierarchy() + void checkEntityReparenting() { // GIVEN TestRenderer renderer; NodeManagers nodeManagers; Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC; - auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) { - Entity *entity = nodeManagers.renderNodesManager()->getOrCreateResource(frontEndEntity.id()); - entity->setNodeManagers(&nodeManagers); - entity->setRenderer(&renderer); - return entity; - }; - - auto backendA = entityCreator(frontendEntityA); - auto backendB = entityCreator(frontendEntityB); - auto backendC = entityCreator(frontendEntityC); + auto backendA = createEntity(renderer, nodeManagers, frontendEntityA); + auto backendB = createEntity(renderer, nodeManagers, frontendEntityB); + auto backendC = createEntity(renderer, nodeManagers, frontendEntityC); // THEN - QVERIFY(backendA->parentEntityId().isNull()); - QVERIFY(backendB->parentEntityId().isNull()); - QVERIFY(backendC->parentEntityId().isNull()); - QVERIFY(backendA->parent() == nullptr); QVERIFY(backendB->parent() == nullptr); QVERIFY(backendC->parent() == nullptr); @@ -233,17 +221,9 @@ private slots: QVERIFY(backendC->childrenHandles().isEmpty()); // WHEN - renderer.clearDirtyBits(0); - QVERIFY(renderer.dirtyBits() == 0); - auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) { - const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id()); - parentChange->setPropertyName("parentEntityUpdated"); - auto parent = entity.parentEntity(); - parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId())); - Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id()); - backendEntity->sceneChangeEvent(parentChange); + backendEntity->syncFromFrontEnd(&entity, false); }; // reparent B to A and C to B. @@ -253,68 +233,111 @@ private slots: sendParentChange(frontendEntityC); // THEN - QVERIFY(renderer.dirtyBits() & AbstractRenderer::EntityHierarchyDirty); + QVERIFY(backendA->parent() == nullptr); + QVERIFY(backendB->parent() == backendA); + QVERIFY(backendC->parent() == backendB); - QVERIFY(backendA->parentEntityId().isNull()); - QVERIFY(backendB->parentEntityId() == frontendEntityA.id()); - QVERIFY(backendC->parentEntityId() == frontendEntityB.id()); + QCOMPARE(backendA->childrenHandles().count(), 1); + QCOMPARE(backendB->childrenHandles().count(), 1); + QVERIFY(backendC->childrenHandles().isEmpty()); + + // WHEN - reparent C to A + frontendEntityC.setParent(&frontendEntityA); + sendParentChange(frontendEntityC); + // THEN + QVERIFY(backendA->parent() == nullptr); + QVERIFY(backendB->parent() == backendA); + QVERIFY(backendC->parent() == backendA); + + QCOMPARE(backendA->childrenHandles().size(), 2); + QVERIFY(backendB->childrenHandles().isEmpty()); + QVERIFY(backendC->childrenHandles().isEmpty()); + + // WHEN - reparent B to null. + frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr)); + sendParentChange(frontendEntityB); + + // THEN QVERIFY(backendA->parent() == nullptr); QVERIFY(backendB->parent() == nullptr); - QVERIFY(backendC->parent() == nullptr); + QVERIFY(backendC->parent() == backendA); - QVERIFY(backendA->childrenHandles().isEmpty()); + QCOMPARE(backendA->childrenHandles().count(), 1); + QVERIFY(!backendA->childrenHandles().contains(backendB->handle())); QVERIFY(backendB->childrenHandles().isEmpty()); QVERIFY(backendC->childrenHandles().isEmpty()); + } + + void checkEntityCleanup() + { + // GIVEN + TestRenderer renderer; + NodeManagers nodeManagers; + Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC; + + auto backendA = createEntity(renderer, nodeManagers, frontendEntityA); + auto backendB = createEntity(renderer, nodeManagers, frontendEntityB); + auto backendC = createEntity(renderer, nodeManagers, frontendEntityC); // WHEN - auto rebuildHierarchy = [](Entity *backend) { - backend->clearEntityHierarchy(); - backend->rebuildEntityHierarchy(); + auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) { + Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id()); + backendEntity->syncFromFrontEnd(&entity, false); }; - rebuildHierarchy(backendA); - rebuildHierarchy(backendB); - rebuildHierarchy(backendC); + + // reparent B and C to A. + frontendEntityB.setParent(&frontendEntityA); + sendParentChange(frontendEntityB); + frontendEntityC.setParent(&frontendEntityA); + sendParentChange(frontendEntityC); // THEN QVERIFY(backendA->parent() == nullptr); QVERIFY(backendB->parent() == backendA); - QVERIFY(backendC->parent() == backendB); + QVERIFY(backendC->parent() == backendA); - QVERIFY(!backendA->childrenHandles().isEmpty()); - QVERIFY(!backendB->childrenHandles().isEmpty()); + QCOMPARE(backendA->childrenHandles().count(), 2); + QVERIFY(backendB->childrenHandles().isEmpty()); QVERIFY(backendC->childrenHandles().isEmpty()); - // WHEN - reparent B to null. - frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr)); - sendParentChange(frontendEntityB); - rebuildHierarchy(backendA); - rebuildHierarchy(backendB); - rebuildHierarchy(backendC); + // WHEN - cleaning up a child + backendC->cleanup(); - QVERIFY(backendA->parentEntityId().isNull()); - QVERIFY(backendB->parentEntityId().isNull()); - QVERIFY(backendC->parentEntityId() == frontendEntityB.id()); + // THEN - the child's parent should be null and it + // should be removed from its parent's list of children + QVERIFY(backendA->parent() == nullptr); + QVERIFY(backendB->parent() == backendA); + QVERIFY(backendC->parent() == nullptr); + + QCOMPARE(backendA->childrenHandles().count(), 1); + QVERIFY(!backendA->childrenHandles().contains(backendC->handle())); + QVERIFY(backendB->childrenHandles().isEmpty()); + QVERIFY(backendC->childrenHandles().isEmpty()); + + // WHEN (cleaning up parent) + backendA->cleanup(); + // THEN (it's children's parent should be set to null) QVERIFY(backendA->parent() == nullptr); QVERIFY(backendB->parent() == nullptr); - QVERIFY(backendC->parent() == backendB); + QVERIFY(backendC->parent() == nullptr); QVERIFY(backendA->childrenHandles().isEmpty()); - QVERIFY(!backendB->childrenHandles().isEmpty()); + QVERIFY(backendB->childrenHandles().isEmpty()); QVERIFY(backendC->childrenHandles().isEmpty()); - // WHEN - cleanup - backendA->cleanup(); + // WHEN backendB->cleanup(); - backendC->cleanup(); - // THEN - QVERIFY(backendA->parentEntityId().isNull()); - QVERIFY(backendB->parentEntityId().isNull()); - QVERIFY(backendC->parentEntityId().isNull()); + // THEN nothing should change + QVERIFY(backendA->childrenHandles().isEmpty()); + QVERIFY(backendB->childrenHandles().isEmpty()); + QVERIFY(backendC->childrenHandles().isEmpty()); - QVERIFY(renderer.dirtyBits() != 0); + QVERIFY(backendA->parent() == nullptr); + QVERIFY(backendB->parent() == nullptr); + QVERIFY(backendC->parent() == nullptr); } void shouldHandleSingleComponentEvents_data() @@ -446,27 +469,13 @@ private slots: NodeManagers nodeManagers; Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC; - auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) { - HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id()); - Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle); - entity->setNodeManagers(&nodeManagers); - entity->setHandle(renderNodeHandle); - entity->setRenderer(&renderer); - return entity; - }; - - auto backendA = entityCreator(frontendEntityA); - auto backendB = entityCreator(frontendEntityB); - auto backendC = entityCreator(frontendEntityC); + auto backendA = createEntity(renderer, nodeManagers, frontendEntityA); + auto backendB = createEntity(renderer, nodeManagers, frontendEntityB); + auto backendC = createEntity(renderer, nodeManagers, frontendEntityC); auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) { - const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id()); - parentChange->setPropertyName("parentEntityUpdated"); - auto parent = entity.parentEntity(); - parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId())); - Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id()); - backendEntity->sceneChangeEvent(parentChange); + backendEntity->syncFromFrontEnd(&entity, false); }; // reparent B to A and C to B. @@ -475,14 +484,6 @@ private slots: frontendEntityC.setParent(&frontendEntityB); sendParentChange(frontendEntityC); - auto rebuildHierarchy = [](Entity *backend) { - backend->clearEntityHierarchy(); - backend->rebuildEntityHierarchy(); - }; - rebuildHierarchy(backendA); - rebuildHierarchy(backendB); - rebuildHierarchy(backendC); - // WHEN int visitCount = 0; auto counter = [&visitCount](const Entity *) { ++visitCount; }; @@ -499,27 +500,17 @@ private slots: NodeManagers nodeManagers; Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC; - auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) { - HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id()); - Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle); - entity->setNodeManagers(&nodeManagers); - entity->setHandle(renderNodeHandle); - entity->setRenderer(&renderer); - return entity; - }; + frontendEntityA.setEnabled(false); + frontendEntityB.setEnabled(false); + frontendEntityC.setEnabled(false); - auto backendA = entityCreator(frontendEntityA); - auto backendB = entityCreator(frontendEntityB); - auto backendC = entityCreator(frontendEntityC); + auto backendA = createEntity(renderer, nodeManagers, frontendEntityA); + auto backendB = createEntity(renderer, nodeManagers, frontendEntityB); + auto backendC = createEntity(renderer, nodeManagers, frontendEntityC); auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) { - const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id()); - parentChange->setPropertyName("parentEntityUpdated"); - auto parent = entity.parentEntity(); - parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId())); - Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id()); - backendEntity->sceneChangeEvent(parentChange); + backendEntity->syncFromFrontEnd(&entity, false); }; // reparent B to A and C to B. @@ -528,14 +519,6 @@ private slots: frontendEntityC.setParent(&frontendEntityB); sendParentChange(frontendEntityC); - auto rebuildHierarchy = [](Entity *backend) { - backend->clearEntityHierarchy(); - backend->rebuildEntityHierarchy(); - }; - rebuildHierarchy(backendA); - rebuildHierarchy(backendB); - rebuildHierarchy(backendC); - // WHEN CompleteVisitor v1(&nodeManagers); EnabledVisitor v2(&nodeManagers); @@ -547,8 +530,8 @@ private slots: // THEN QCOMPARE(v1.count, 3); - QCOMPARE(v2.count, 1); // nodes disabled by default but the first one is still visited before visitation finds out it's disabled - QCOMPARE(v3.count, 0); // nodes disabled by default + QCOMPARE(v2.count, 1); // nodes disabled but the first one is still visited before visitation finds out it's disabled + QCOMPARE(v3.count, 0); // nodes disabled } void accumulator() @@ -558,27 +541,17 @@ private slots: NodeManagers nodeManagers; Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC; - auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) { - HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id()); - Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle); - entity->setNodeManagers(&nodeManagers); - entity->setHandle(renderNodeHandle); - entity->setRenderer(&renderer); - return entity; - }; + frontendEntityA.setEnabled(false); + frontendEntityB.setEnabled(false); + frontendEntityC.setEnabled(false); - auto backendA = entityCreator(frontendEntityA); - auto backendB = entityCreator(frontendEntityB); - auto backendC = entityCreator(frontendEntityC); + auto backendA = createEntity(renderer, nodeManagers, frontendEntityA); + auto backendB = createEntity(renderer, nodeManagers, frontendEntityB); + auto backendC = createEntity(renderer, nodeManagers, frontendEntityC); auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) { - const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id()); - parentChange->setPropertyName("parentEntityUpdated"); - auto parent = entity.parentEntity(); - parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId())); - Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id()); - backendEntity->sceneChangeEvent(parentChange); + backendEntity->syncFromFrontEnd(&entity, false); }; // reparent B to A and C to B. @@ -587,14 +560,6 @@ private slots: frontendEntityC.setParent(&frontendEntityB); sendParentChange(frontendEntityC); - auto rebuildHierarchy = [](Entity *backend) { - backend->clearEntityHierarchy(); - backend->rebuildEntityHierarchy(); - }; - rebuildHierarchy(backendA); - rebuildHierarchy(backendB); - rebuildHierarchy(backendC); - // WHEN EntityAccumulator v1(&nodeManagers); EntityAccumulator v2([](Entity *e) { return e->isEnabled(); }, &nodeManagers); @@ -605,6 +570,18 @@ private slots: QCOMPARE(r1.count(), 3); QCOMPARE(r2.count(), 0); } + +private: + Entity *createEntity(TestRenderer &renderer, NodeManagers &nodeManagers, const Qt3DCore::QEntity &frontEndEntity) { + HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id()); + Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle); + entity->setNodeManagers(&nodeManagers); + entity->setHandle(renderNodeHandle); + entity->setRenderer(&renderer); + entity->syncFromFrontEnd(&frontEndEntity, true); + return entity; + } + }; QTEST_APPLESS_MAIN(tst_RenderEntity) diff --git a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp index 80a6ae519..25262a772 100644 --- a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp +++ b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp @@ -81,7 +81,12 @@ public: }); for (const auto node: nodes) - d_func()->createBackendNode(node); + d_func()->createBackendNode({ + node->id(), + Qt3DCore::QNodePrivate::get(node)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + node + }); } ~TestAspect() diff --git a/tests/auto/render/framegraphnode/framegraphnode.pro b/tests/auto/render/framegraphnode/framegraphnode.pro index 577bc9775..f47fc1866 100644 --- a/tests/auto/render/framegraphnode/framegraphnode.pro +++ b/tests/auto/render/framegraphnode/framegraphnode.pro @@ -8,3 +8,4 @@ CONFIG += testcase SOURCES += tst_framegraphnode.cpp include(../commons/commons.pri) +include(../../core/common/common.pri) diff --git a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp index 22bd872dc..4ad1ce6f5 100644 --- a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp +++ b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp @@ -33,6 +33,7 @@ #include <Qt3DCore/qpropertyupdatedchange.h> #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> #include "testrenderer.h" +#include "qbackendnodetester.h" class MyFrameGraphNode : public Qt3DRender::Render::FrameGraphNode { @@ -52,12 +53,12 @@ public: {} }; -class tst_FrameGraphNode : public QObject +class tst_FrameGraphNode : public Qt3DCore::QBackendNodeTester { Q_OBJECT public: tst_FrameGraphNode(QObject *parent = nullptr) - : QObject(parent) + : Qt3DCore::QBackendNodeTester(parent) {} ~tst_FrameGraphNode() @@ -216,10 +217,9 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN - const Qt3DCore::QNodeId fgNode1Id = Qt3DCore::QNodeId::createId(); - - Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode(); + Qt3DRender::QFrameGraphNode *frontendFGNode = new MyQFrameGraphNode(); Qt3DRender::QFrameGraphNode *frontendFGChild = new MyQFrameGraphNode(); + Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode(); Qt3DRender::Render::FrameGraphNode *backendFGChild = new MyFrameGraphNode(); QScopedPointer<Qt3DRender::Render::FrameGraphManager> manager(new Qt3DRender::Render::FrameGraphManager()); @@ -229,44 +229,41 @@ private Q_SLOTS: backendFGNode->setRenderer(&renderer); backendFGChild->setRenderer(&renderer); - setIdInternal(backendFGNode, fgNode1Id); + setIdInternal(backendFGNode, frontendFGNode->id()); setIdInternal(backendFGChild, frontendFGChild->id()); - manager->appendNode(fgNode1Id, backendFGNode); + manager->appendNode(frontendFGNode->id(), backendFGNode); manager->appendNode(frontendFGChild->id(), backendFGChild); backendFGNode->setFrameGraphManager(manager.data()); backendFGChild->setFrameGraphManager(manager.data()); - - // To geneate the type_info in the QNodePrivate of frontendFGChild - Qt3DCore::QNodeCreatedChangeGenerator generator(frontendFGChild); + simulateInitializationSync(frontendFGNode, backendFGNode); + simulateInitializationSync(frontendFGChild, backendFGChild); QCOMPARE(backendFGNode->childrenIds().size(), 0); { // WHEN - renderer.clearDirtyBits(0); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id()); - change->setPropertyName("parentFrameGraphUpdated"); - change->setValue(QVariant::fromValue(fgNode1Id)); - backendFGChild->sceneChangeEvent(change); + renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); + frontendFGChild->setParent(frontendFGNode); + backendFGChild->syncFromFrontEnd(frontendFGChild, false); // THEN QCOMPARE(backendFGNode->childrenIds().size(), 1); - QCOMPARE(backendFGChild->parentId(), fgNode1Id); + QCOMPARE(backendFGChild->parentId(), frontendFGNode->id()); + QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); } { // WHEN - renderer.clearDirtyBits(0); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id()); - change->setPropertyName("parentFrameGraphUpdated"); - change->setValue(QVariant::fromValue(Qt3DCore::QNodeId())); - backendFGChild->sceneChangeEvent(change); + renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); + frontendFGChild->setParent(Q_NODE_NULLPTR); + backendFGChild->syncFromFrontEnd(frontendFGChild, false); // THEN QCOMPARE(backendFGNode->childrenIds().size(), 0); QVERIFY(backendFGChild->parentId().isNull()); + QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); } } diff --git a/tests/auto/render/geometry/tst_geometry.cpp b/tests/auto/render/geometry/tst_geometry.cpp index 7e65d27aa..54a28e776 100644 --- a/tests/auto/render/geometry/tst_geometry.cpp +++ b/tests/auto/render/geometry/tst_geometry.cpp @@ -50,6 +50,7 @@ public: class tst_RenderGeometry : public Qt3DCore::QBackendNodeTester { Q_OBJECT + private Q_SLOTS: void checkPeerPropertyMirroring() @@ -72,7 +73,7 @@ private Q_SLOTS: renderGeometry.setRenderer(&renderer); // WHEN - simulateInitialization(&geometry, &renderGeometry); + simulateInitializationSync(&geometry, &renderGeometry); // THEN QCOMPARE(renderGeometry.peerId(), geometry.id()); @@ -80,8 +81,9 @@ private Q_SLOTS: QCOMPARE(renderGeometry.attributes().count(), 4); QCOMPARE(renderGeometry.boundingPositionAttribute(), attr1.id()); - for (int i = 0; i < 4; ++i) - QCOMPARE(geometry.attributes().at(i)->id(), renderGeometry.attributes().at(i)); + Qt3DCore::QNodeIdVector attribs = Qt3DCore::qIdsForNodes(geometry.attributes()); + std::sort(std::begin(attribs), std::end(attribs)); + QCOMPARE(attribs, renderGeometry.attributes()); } void checkSetRendererDirtyOnInitialization() @@ -97,7 +99,7 @@ private Q_SLOTS: QCOMPARE(renderer.dirtyBits(), 0); // WHEN - simulateInitialization(&geometry, &renderGeometry); + simulateInitializationSync(&geometry, &renderGeometry); // THEN QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::GeometryDirty); @@ -130,7 +132,7 @@ private Q_SLOTS: geometry.addAttribute(&attr4); // WHEN - simulateInitialization(&geometry, &renderGeometry); + simulateInitializationSync(&geometry, &renderGeometry); renderGeometry.cleanup(); // THEN @@ -145,13 +147,15 @@ private Q_SLOTS: TestRenderer renderer; Qt3DRender::Render::Geometry renderGeometry; renderGeometry.setRenderer(&renderer); + Qt3DRender::QGeometry geometry; + + simulateInitializationSync(&geometry, &renderGeometry); DummyAttribute attribute; // WHEN - const auto nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &attribute); - nodeAddedChange->setPropertyName("attribute"); - renderGeometry.sceneChangeEvent(nodeAddedChange); + geometry.addAttribute(&attribute); + renderGeometry.syncFromFrontEnd(&geometry, false); // THEN QCOMPARE(renderGeometry.attributes().count(), 1); @@ -163,9 +167,8 @@ private Q_SLOTS: QVERIFY(!renderGeometry.isDirty()); // WHEN - const auto nodeRemovedChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &attribute); - nodeRemovedChange->setPropertyName("attribute"); - renderGeometry.sceneChangeEvent(nodeRemovedChange); + geometry.removeAttribute(&attribute); + renderGeometry.syncFromFrontEnd(&geometry, false); // THEN QCOMPARE(renderGeometry.attributes().count(), 0); @@ -177,14 +180,11 @@ private Q_SLOTS: QVERIFY(!renderGeometry.isDirty()); // WHEN - const Qt3DCore::QNodeId boundingAttrId = Qt3DCore::QNodeId::createId(); - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(QVariant::fromValue(boundingAttrId)); - updateChange->setPropertyName("boundingVolumePositionAttribute"); - renderGeometry.sceneChangeEvent(updateChange); + geometry.setBoundingVolumePositionAttribute(&attribute); + renderGeometry.syncFromFrontEnd(&geometry, false); // THEN - QCOMPARE(renderGeometry.boundingPositionAttribute(), boundingAttrId); + QCOMPARE(renderGeometry.boundingPositionAttribute(), attribute.id()); QVERIFY(!renderGeometry.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp index d07ec9914..db997a5e5 100644 --- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp +++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp @@ -75,6 +75,7 @@ public: class tst_RenderGeometryRenderer : public Qt3DCore::QBackendNodeTester { Q_OBJECT + private Q_SLOTS: void checkPeerPropertyMirroring() @@ -102,7 +103,7 @@ private Q_SLOTS: // WHEN renderGeometryRenderer.setRenderer(&renderer); renderGeometryRenderer.setManager(&geometryRendererManager); - simulateInitialization(&geometryRenderer, &renderGeometryRenderer); + simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer); // THEN QCOMPARE(renderGeometryRenderer.peerId(), geometryRenderer.id()); @@ -163,7 +164,7 @@ private Q_SLOTS: // WHEN renderGeometryRenderer.setRenderer(&renderer); renderGeometryRenderer.setManager(&geometryRendererManager); - simulateInitialization(&geometryRenderer, &renderGeometryRenderer); + simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer); renderGeometryRenderer.cleanup(); // THEN @@ -184,210 +185,185 @@ private Q_SLOTS: void checkPropertyChanges() { // GIVEN - Qt3DRender::Render::GeometryRenderer renderGeometryRenderer; + Qt3DRender::QGeometryRenderer frontEndRenderer; + Qt3DRender::Render::GeometryRenderer backEndRenderer; TestRenderer renderer; - renderGeometryRenderer.setRenderer(&renderer); + backEndRenderer.setRenderer(&renderer); - QVERIFY(!renderGeometryRenderer.isDirty()); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("instanceCount"); - updateChange->setValue(2); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setInstanceCount(2); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.instanceCount(), 2); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.instanceCount(), 2); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("vertexCount"); - updateChange->setValue(56); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setVertexCount(56); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.vertexCount(), 56); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.vertexCount(), 56); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("indexOffset"); - updateChange->setValue(65); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setIndexOffset(65); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.indexOffset(), 65); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.indexOffset(), 65); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("firstInstance"); - updateChange->setValue(82); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setFirstInstance(82); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.firstInstance(), 82); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.firstInstance(), 82); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("indexBufferByteOffset"); - updateChange->setValue(96); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setIndexBufferByteOffset(96); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), 96); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.indexBufferByteOffset(), 96); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("restartIndexValue"); - updateChange->setValue(46); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setRestartIndexValue(46); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.restartIndexValue(), 46); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.restartIndexValue(), 46); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("primitiveRestartEnabled"); - updateChange->setValue(true); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setPrimitiveRestartEnabled(true); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.primitiveRestartEnabled(), true); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.primitiveRestartEnabled(), true); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("primitiveType"); - updateChange->setValue(static_cast<int>(Qt3DRender::QGeometryRenderer::LineLoop)); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::LineLoop); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::LineLoop); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::LineLoop); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("geometryFactory"); Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(1450)); - updateChange->setValue(QVariant::fromValue(factory)); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setGeometryFactory(factory); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.geometryFactory(), factory); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.geometryFactory(), factory); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN we set an identical factory again - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("geometryFactory"); Qt3DRender::QGeometryFactoryPtr factory2(new TestFactory(1450)); - updateChange->setValue(QVariant::fromValue(factory2)); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setGeometryFactory(factory2); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN not dirty and still uses original factory - QCOMPARE(renderGeometryRenderer.geometryFactory(), factory); - QVERIFY(!renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.geometryFactory(), factory); + QVERIFY(!backEndRenderer.isDirty()); // WHEN DummyGeometry geometry; const Qt3DCore::QNodeId geometryId = geometry.id(); - const auto nodeAddedChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - nodeAddedChange->setPropertyName("geometry"); - nodeAddedChange->setValue(QVariant::fromValue(geometryId)); - renderGeometryRenderer.sceneChangeEvent(nodeAddedChange); + frontEndRenderer.setGeometry(&geometry); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.geometryId(), geometryId); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.geometryId(), geometryId); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - const auto nodeRemovedChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - nodeRemovedChange->setPropertyName("geometry"); - nodeRemovedChange->setValue(QVariant::fromValue(Qt3DCore::QNodeId())); - renderGeometryRenderer.sceneChangeEvent(nodeRemovedChange); + frontEndRenderer.setGeometry(nullptr); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.geometryId(), Qt3DCore::QNodeId()); - QVERIFY(renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.geometryId(), Qt3DCore::QNodeId()); + QVERIFY(backEndRenderer.isDirty()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderGeometryRenderer.unsetDirty(); - QVERIFY(!renderGeometryRenderer.isDirty()); + backEndRenderer.unsetDirty(); + QVERIFY(!backEndRenderer.isDirty()); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(true)); - updateChange->setPropertyName("enabled"); - renderGeometryRenderer.sceneChangeEvent(updateChange); + frontEndRenderer.setEnabled(true); + backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false); // THEN - QCOMPARE(renderGeometryRenderer.isEnabled(), true); - QVERIFY(!renderGeometryRenderer.isDirty()); + QCOMPARE(backEndRenderer.isEnabled(), true); + QVERIFY(!backEndRenderer.isDirty()); } void checkSetRendererDirtyOnInitialization() @@ -405,7 +381,7 @@ private Q_SLOTS: QCOMPARE(renderer.dirtyBits(), 0); // WHEN - simulateInitialization(&geometryRenderer, &renderGeometryRenderer); + simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer); // THEN QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::GeometryDirty); diff --git a/tests/auto/render/joint/tst_joint.cpp b/tests/auto/render/joint/tst_joint.cpp index 13aa915d2..c08d36725 100644 --- a/tests/auto/render/joint/tst_joint.cpp +++ b/tests/auto/render/joint/tst_joint.cpp @@ -60,6 +60,7 @@ private Q_SLOTS: Joint backendJoint; backendJoint.setRenderer(&renderer); backendJoint.setJointManager(nodeManagers.jointManager()); + backendJoint.setSkeletonManager(nodeManagers.skeletonManager()); QJoint joint; joint.setTranslation(QVector3D(1.0f, 2.0f, 3.0f)); @@ -77,7 +78,7 @@ private Q_SLOTS: } // WHEN - simulateInitialization(&joint, &backendJoint); + simulateInitializationSync(&joint, &backendJoint); // THEN QCOMPARE(backendJoint.peerId(), joint.id()); @@ -100,6 +101,7 @@ private Q_SLOTS: Joint backendJoint; backendJoint.setRenderer(&renderer); backendJoint.setJointManager(nodeManagers.jointManager()); + backendJoint.setSkeletonManager(nodeManagers.skeletonManager()); // THEN QVERIFY(backendJoint.peerId().isNull()); @@ -128,7 +130,7 @@ private Q_SLOTS: } // WHEN - simulateInitialization(&joint, &backendJoint); + simulateInitializationSync(&joint, &backendJoint); backendJoint.cleanup(); // THEN @@ -235,6 +237,88 @@ private Q_SLOTS: } } } + + void checkDirectPropertyChanges() + { + // GIVEN + TestRenderer renderer; + NodeManagers nodeManagers; + renderer.setNodeManagers(&nodeManagers); + Joint backendJoint; + backendJoint.setRenderer(&renderer); + backendJoint.setJointManager(nodeManagers.jointManager()); + backendJoint.setSkeletonManager(nodeManagers.skeletonManager()); + + QJoint joint; + simulateInitializationSync(&joint, &backendJoint); + + // WHEN + joint.setEnabled(false); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + QCOMPARE(backendJoint.isEnabled(), false); + + // WHEN + const QVector3D newTranslation = QVector3D(1.0f, 2.0f, 3.0f); + joint.setTranslation(newTranslation); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + QCOMPARE(backendJoint.translation(), newTranslation); + + // WHEN + const QQuaternion newRotation = QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, 45.0f); + joint.setRotation(newRotation); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + QCOMPARE(backendJoint.rotation(), newRotation); + + // WHEN + const QVector3D newScale = QVector3D(1.5f, 2.5f, 3.5f); + joint.setScale(newScale); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + QCOMPARE(backendJoint.scale(), newScale); + + // WHEN + QMatrix4x4 newInverseBind; + newInverseBind.scale(5.4f); + joint.setInverseBindMatrix(newInverseBind); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + QCOMPARE(backendJoint.inverseBindMatrix(), newInverseBind); + + // WHEN + QVector<QJoint *> childJoints; + for (int i = 0; i < 10; ++i) { + const auto childJoint = new QJoint(); + joint.addChildJoint(childJoint); + childJoints.push_back(childJoint); + } + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + for (int i = 0; i < childJoints.size(); ++i) { + QCOMPARE(backendJoint.childJointIds()[i], childJoints[i]->id()); + } + + for (int i = 0; i < 10; ++i) { + // WHEN + const auto childJoint = childJoints.takeLast(); + + joint.removeChildJoint(childJoint); + backendJoint.syncFromFrontEnd(&joint, false); + + // THEN + for (int i = 0; i < childJoints.size(); ++i) { + QCOMPARE(backendJoint.childJointIds()[i], childJoints[i]->id()); + } + } + } }; QTEST_APPLESS_MAIN(tst_Joint) diff --git a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp index 8c72829e0..255ff5ea8 100644 --- a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp +++ b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp @@ -33,7 +33,6 @@ #include <Qt3DRender/private/entity_p.h> #include <Qt3DRender/private/filterlayerentityjob_p.h> #include <Qt3DRender/private/updatetreeenabledjob_p.h> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DRender/qlayer.h> #include <Qt3DRender/qlayerfilter.h> #include "testaspect.h" @@ -634,10 +633,6 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id()); - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(aspect->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob; updateTreeEnabledJob.setRoot(backendRoot); updateTreeEnabledJob.setManagers(aspect->nodeManagers()); diff --git a/tests/auto/render/material/tst_material.cpp b/tests/auto/render/material/tst_material.cpp index 9dfa0c246..e47eaea34 100644 --- a/tests/auto/render/material/tst_material.cpp +++ b/tests/auto/render/material/tst_material.cpp @@ -45,6 +45,7 @@ using namespace Qt3DRender::Render; class tst_RenderMaterial : public Qt3DCore::QBackendNodeTester { Q_OBJECT + public: tst_RenderMaterial() {} @@ -117,7 +118,7 @@ void tst_RenderMaterial::shouldHavePropertiesMirroringFromItsPeer() // GIVEN backend.setRenderer(&renderer); - simulateInitialization(frontendMaterial, &backend); + simulateInitializationSync(frontendMaterial, &backend); // THEN QVERIFY(backend.isEnabled() == frontendMaterial->isEnabled()); @@ -136,15 +137,17 @@ void tst_RenderMaterial::shouldHavePropertiesMirroringFromItsPeer() void tst_RenderMaterial::shouldHandleParametersPropertyChange() { // GIVEN - QScopedPointer<QParameter> parameter(new QParameter()); + QParameter *parameter = new QParameter(); Material backend; TestRenderer renderer; backend.setRenderer(&renderer); + QMaterial material; + simulateInitializationSync(&material, &backend); + // WHEN - const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), parameter.data()); - addChange->setPropertyName("parameter"); - backend.sceneChangeEvent(addChange); + material.addParameter(parameter); + backend.syncFromFrontEnd(&material, false); // THEN QCOMPARE(backend.parameters().count(), 1); @@ -152,9 +155,8 @@ void tst_RenderMaterial::shouldHandleParametersPropertyChange() QVERIFY(renderer.dirtyBits() != 0); // WHEN - const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), parameter.data()); - removeChange->setPropertyName("parameter"); - backend.sceneChangeEvent(removeChange); + material.removeParameter(parameter); + backend.syncFromFrontEnd(&material, false); // THEN QVERIFY(backend.parameters().isEmpty()); @@ -167,24 +169,23 @@ void tst_RenderMaterial::shouldHandleEnablePropertyChange() TestRenderer renderer; backend.setRenderer(&renderer); + QMaterial material; + simulateInitializationSync(&material, &backend); + // WHEN - auto updateChange = QPropertyUpdatedChangePtr::create(QNodeId()); - updateChange->setValue(true); - updateChange->setPropertyName("enabled"); - backend.sceneChangeEvent(updateChange); + material.setEnabled(false); + backend.syncFromFrontEnd(&material, false); // THEN - QVERIFY(backend.isEnabled()); + QVERIFY(!backend.isEnabled()); QVERIFY(renderer.dirtyBits() != 0); // WHEN - auto secondUpdateChange = QPropertyUpdatedChangePtr::create(QNodeId()); - secondUpdateChange->setValue(false); - secondUpdateChange->setPropertyName("enabled"); - backend.sceneChangeEvent(secondUpdateChange); + material.setEnabled(true); + backend.syncFromFrontEnd(&material, false); // THEN - QVERIFY(!backend.isEnabled()); + QVERIFY(backend.isEnabled()); } @@ -195,15 +196,16 @@ void tst_RenderMaterial::shouldHandleEffectPropertyChange() TestRenderer renderer; backend.setRenderer(&renderer); + QMaterial material; + simulateInitializationSync(&material, &backend); + // WHEN - QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - Qt3DCore::QNodeId effectId = Qt3DCore::QNodeId::createId(); - updateChange->setValue(QVariant::fromValue(effectId)); - updateChange->setPropertyName("effect"); - backend.sceneChangeEvent(updateChange); + QEffect effect; + material.setEffect(&effect); + backend.syncFromFrontEnd(&material, false); // THEN - QCOMPARE(backend.effect(), effectId); + QCOMPARE(backend.effect(), effect.id()); QVERIFY(renderer.dirtyBits() != 0); } diff --git a/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp b/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp index c088cb84f..236faa8f0 100644 --- a/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp +++ b/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp @@ -76,7 +76,12 @@ public: }); for (const auto node: nodes) - d_func()->createBackendNode(node); + d_func()->createBackendNode({ + node->id(), + Qt3DCore::QNodePrivate::get(node)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + node + }); const auto handles = nodeManagers()->techniqueManager()->activeHandles(); for (const auto &handle: handles) { diff --git a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp index 71cf3f567..708659e4e 100644 --- a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp +++ b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp @@ -64,7 +64,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::MemoryBarrier backendMemoryBarrier; backendMemoryBarrier.setRenderer(&renderer); - simulateInitialization(&memoryBarrier, &backendMemoryBarrier); + simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier); // THEN QCOMPARE(backendMemoryBarrier.isEnabled(), true); @@ -78,7 +78,7 @@ private Q_SLOTS: Qt3DRender::Render::MemoryBarrier backendMemoryBarrier; backendMemoryBarrier.setRenderer(&renderer); memoryBarrier.setEnabled(false); - simulateInitialization(&memoryBarrier, &backendMemoryBarrier); + simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier); // THEN QCOMPARE(backendMemoryBarrier.peerId(), memoryBarrier.id()); @@ -93,14 +93,15 @@ private Q_SLOTS: Qt3DRender::Render::MemoryBarrier backendMemoryBarrier; TestRenderer renderer; backendMemoryBarrier.setRenderer(&renderer); + Qt3DRender::QMemoryBarrier memoryBarrier; + + simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendMemoryBarrier.sceneChangeEvent(change); + memoryBarrier.setEnabled(newValue); + backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false); // THEN QCOMPARE(backendMemoryBarrier.isEnabled(), newValue); @@ -110,10 +111,8 @@ private Q_SLOTS: { // WHEN const Qt3DRender::QMemoryBarrier::Operations newValue(Qt3DRender::QMemoryBarrier::AtomicCounter|Qt3DRender::QMemoryBarrier::ElementArray); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("waitOperations"); - change->setValue(QVariant::fromValue(newValue)); - backendMemoryBarrier.sceneChangeEvent(change); + memoryBarrier.setWaitOperations(newValue); + backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false); // THEN QCOMPARE(backendMemoryBarrier.waitOperations(), newValue); diff --git a/tests/auto/render/parameter/tst_parameter.cpp b/tests/auto/render/parameter/tst_parameter.cpp index 3b83c1c82..44e7b7020 100644 --- a/tests/auto/render/parameter/tst_parameter.cpp +++ b/tests/auto/render/parameter/tst_parameter.cpp @@ -66,7 +66,7 @@ private Q_SLOTS: // WHEN backendParameter.setRenderer(&renderer); - simulateInitialization(¶meter, &backendParameter); + simulateInitializationSync(¶meter, &backendParameter); backendParameter.cleanup(); // THEN @@ -89,7 +89,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::Parameter backendParameter; backendParameter.setRenderer(&renderer); - simulateInitialization(¶meter, &backendParameter); + simulateInitializationSync(¶meter, &backendParameter); // THEN QCOMPARE(backendParameter.isEnabled(), true); @@ -105,7 +105,7 @@ private Q_SLOTS: Qt3DRender::Render::Parameter backendParameter; backendParameter.setRenderer(&renderer); parameter.setEnabled(false); - simulateInitialization(¶meter, &backendParameter); + simulateInitializationSync(¶meter, &backendParameter); // THEN QCOMPARE(backendParameter.peerId(), parameter.id()); @@ -121,13 +121,14 @@ private Q_SLOTS: TestRenderer renderer; backendParameter.setRenderer(&renderer); + Qt3DRender::QParameter parameter; + simulateInitializationSync(¶meter, &backendParameter); + { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendParameter.sceneChangeEvent(change); + parameter.setEnabled(newValue); + backendParameter.syncFromFrontEnd(¶meter, false); // THEN QCOMPARE(backendParameter.isEnabled(), newValue); @@ -137,10 +138,8 @@ private Q_SLOTS: { // WHEN const QString newValue = QStringLiteral("C7"); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("name"); - change->setValue(QVariant::fromValue(newValue)); - backendParameter.sceneChangeEvent(change); + parameter.setName(newValue); + backendParameter.syncFromFrontEnd(¶meter, false); // THEN QCOMPARE(backendParameter.name(), newValue); @@ -152,10 +151,8 @@ private Q_SLOTS: // WHEN const QVariant value = QVariant::fromValue(QVector3D(350.0f, 427.0f, 454.0f)); const Qt3DRender::Render::UniformValue newValue = Qt3DRender::Render::UniformValue::fromVariant(value); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("value"); - change->setValue(value); - backendParameter.sceneChangeEvent(change); + parameter.setValue(value); + backendParameter.syncFromFrontEnd(¶meter, false); // THEN QCOMPARE(backendParameter.uniformValue(), newValue); diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp index a6b09d179..1fbdc4d04 100644 --- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp +++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp @@ -48,7 +48,6 @@ #include <Qt3DRender/private/qrenderaspect_p.h> #include <Qt3DRender/private/pickboundingvolumejob_p.h> #include <Qt3DRender/private/pickboundingvolumeutils_p.h> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DRender/private/updatemeshtrianglelistjob_p.h> #include <Qt3DRender/private/updateworldboundingvolumejob_p.h> #include <Qt3DRender/private/updateworldtransformjob_p.h> @@ -91,6 +90,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -101,7 +117,7 @@ public: QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes)); Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); @@ -133,10 +149,6 @@ namespace { void runRequiredJobs(Qt3DRender::TestAspect *test) { - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(test->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; updateWorldTransform.setRoot(test->sceneRoot()); updateWorldTransform.setManagers(test->nodeManagers()); diff --git a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp index c1f1e8ec4..88059e31a 100644 --- a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp +++ b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp @@ -66,7 +66,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::ProximityFilter backendProximityFilter; backendProximityFilter.setRenderer(&renderer); - simulateInitialization(&proximityFilter, &backendProximityFilter); + simulateInitializationSync(&proximityFilter, &backendProximityFilter); // THEN QCOMPARE(backendProximityFilter.isEnabled(), true); @@ -81,7 +81,7 @@ private Q_SLOTS: Qt3DRender::Render::ProximityFilter backendProximityFilter; backendProximityFilter.setRenderer(&renderer); proximityFilter.setEnabled(false); - simulateInitialization(&proximityFilter, &backendProximityFilter); + simulateInitializationSync(&proximityFilter, &backendProximityFilter); // THEN QCOMPARE(backendProximityFilter.peerId(), proximityFilter.id()); @@ -93,17 +93,17 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN + Qt3DRender::QProximityFilter proximityFilter; Qt3DRender::Render::ProximityFilter backendProximityFilter; TestRenderer renderer; backendProximityFilter.setRenderer(&renderer); + simulateInitializationSync(&proximityFilter, &backendProximityFilter); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendProximityFilter.sceneChangeEvent(change); + proximityFilter.setEnabled(newValue); + backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter); // THEN QCOMPARE(backendProximityFilter.isEnabled(), newValue); @@ -113,10 +113,9 @@ private Q_SLOTS: { // WHEN const float newValue = 383.0f; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("distanceThreshold"); - change->setValue(QVariant::fromValue(newValue)); - backendProximityFilter.sceneChangeEvent(change); + proximityFilter.setDistanceThreshold(newValue); + backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter); + // THEN QCOMPARE(backendProximityFilter.distanceThreshold(), newValue); @@ -125,14 +124,12 @@ private Q_SLOTS: } { // WHEN - const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId(); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("entity"); - change->setValue(QVariant::fromValue(newValue)); - backendProximityFilter.sceneChangeEvent(change); + Qt3DCore::QEntity e; + proximityFilter.setEntity(&e); + backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter); // THEN - QCOMPARE(backendProximityFilter.entityId(), newValue); + QCOMPARE(backendProximityFilter.entityId(), e.id()); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); } diff --git a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp index c8d862b2e..07adf12b5 100644 --- a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp +++ b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp @@ -247,10 +247,6 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id()); - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(aspect->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob; updateTreeEnabledJob.setRoot(backendRoot); updateTreeEnabledJob.setManagers(aspect->nodeManagers()); diff --git a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp index 04364e2d9..6db8d20f5 100644 --- a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp +++ b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp @@ -37,6 +37,7 @@ #include <Qt3DCore/qpropertynodeaddedchange.h> #include <Qt3DCore/qpropertynoderemovedchange.h> #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h> +#include <Qt3DCore/private/qnodevisitor_p.h> #include <Qt3DCore/qnodecreatedchange.h> #include "testpostmanarbiter.h" @@ -1099,28 +1100,6 @@ private Q_SLOTS: { { // GIVEN - FakeTexture abstractTexture; - Qt3DRender::QTextureDataUpdate update; - - // WHEN - abstractTexture.updateData(update); - - // THEN (no arbiter -> should be stored in the initial changes) - Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture); - const QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges(); - - QCOMPARE(creationChanges.size(), 1); - const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first()); - - QVERIFY(typedChange); - const Qt3DRender::QAbstractTextureData data = typedChange->data; - - QCOMPARE(data.initialDataUpdates.size(), 1); - QVERIFY(data.initialDataUpdates.contains(update)); - } - - { - // GIVEN TestArbiter arbiter; FakeTexture abstractTexture; Qt3DRender::QTextureDataUpdate update; @@ -1131,23 +1110,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN (arbiter -> should not be stored in the initial changes but only send as a property change) - Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture); - const QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges(); - - QCOMPARE(creationChanges.size(), 1); - const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first()); - - QVERIFY(typedChange); - const Qt3DRender::QAbstractTextureData data = typedChange->data; - - QCOMPARE(data.initialDataUpdates.size(), 0); - - // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "updateData"); - QCOMPARE(change->value().value<Qt3DRender::QTextureDataUpdate>(), update); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + auto d = static_cast<Qt3DRender::QAbstractTexturePrivate*>(Qt3DRender::QAbstractTexturePrivate::get(&abstractTexture)); + QCOMPARE(d->m_pendingDataUpdates.size(), 1); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture); } } diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp index 8a9a25408..94c0a49cb 100644 --- a/tests/auto/render/qbuffer/tst_qbuffer.cpp +++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp @@ -154,12 +154,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "dataGenerator"); - QCOMPARE(change->value().value<Qt3DRender::QBufferDataGeneratorPtr>(), functor); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), buffer.data()); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN buffer->setSyncData(true); @@ -176,13 +174,8 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - QCOMPARE(buffer->data(), QByteArrayLiteral("ZL1")); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "updateData"); - Qt3DRender::QBufferUpdate updateData = change->value().value<Qt3DRender::QBufferUpdate>(); - QCOMPARE(updateData.offset, 1); - QCOMPARE(updateData.data, QByteArrayLiteral("L1")); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), buffer.data()); } }; diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp index 214305e53..229dff565 100644 --- a/tests/auto/render/qcamera/tst_qcamera.cpp +++ b/tests/auto/render/qcamera/tst_qcamera.cpp @@ -34,7 +34,6 @@ #include <qbackendnodetester.h> #include <Qt3DCore/QEntity> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DCore/private/qaspectjobmanager_p.h> #include <Qt3DCore/private/qnodevisitor_p.h> #include <Qt3DCore/qpropertyupdatedchange.h> @@ -80,6 +79,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -90,7 +106,7 @@ public: QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes)); Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); @@ -124,10 +140,6 @@ namespace { void runRequiredJobs(Qt3DRender::TestAspect *test) { - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(test->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; updateWorldTransform.setRoot(test->sceneRoot()); updateWorldTransform.setManagers(test->nodeManagers()); diff --git a/tests/auto/render/qeffect/tst_qeffect.cpp b/tests/auto/render/qeffect/tst_qeffect.cpp index 7449fee2c..955b58a1e 100644 --- a/tests/auto/render/qeffect/tst_qeffect.cpp +++ b/tests/auto/render/qeffect/tst_qeffect.cpp @@ -217,13 +217,8 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QVERIFY(effect.parameters().contains(¶meter)); } { @@ -232,13 +227,8 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->removedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QVERIFY(!effect.parameters().contains(¶meter)); } } @@ -257,13 +247,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "technique"); - QCOMPARE(change->addedNodeId(), technique.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &effect); + arbiter.dirtyNodes.clear(); } { @@ -272,13 +259,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "technique"); - QCOMPARE(change->removedNodeId(), technique.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &effect); + arbiter.dirtyNodes.clear(); } } diff --git a/tests/auto/render/qgeometry/tst_qgeometry.cpp b/tests/auto/render/qgeometry/tst_qgeometry.cpp index 55b7e752c..b82c53de1 100644 --- a/tests/auto/render/qgeometry/tst_qgeometry.cpp +++ b/tests/auto/render/qgeometry/tst_qgeometry.cpp @@ -130,13 +130,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeAddedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(nodeAddedChange->propertyName(), "attribute"); - QCOMPARE(nodeAddedChange->addedNodeId(), attr.id()); - QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), geometry.data()); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN geometry->addAttribute(&attr); @@ -144,17 +142,16 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN geometry->removeAttribute(&attr); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "attribute"); - QCOMPARE(nodeRemovedChange->removedNodeId(), attr.id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), geometry.data()); arbiter.events.clear(); } diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp index 15cf98de0..b03d48663 100644 --- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp +++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp @@ -262,13 +262,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "geometryFactory"); - QCOMPARE(change->value().value<Qt3DRender::QGeometryFactoryPtr>(), factory); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data()); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN Qt3DRender::QGeometry geom; diff --git a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp index c7686bae2..4bc766b58 100644 --- a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp +++ b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp @@ -119,14 +119,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(addChange->propertyName(), "layer"); - QCOMPARE(addChange->subjectId(), layerFilter->id()); - QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(0)->id()); - QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN layer = new Qt3DRender::QLayer(layerFilter.data()); @@ -135,14 +132,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(addChange->propertyName(), "layer"); - QCOMPARE(addChange->subjectId(), layerFilter->id()); - QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(1)->id()); - QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN layer = layerFilter->layers().at(0); @@ -150,14 +144,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto removeChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(removeChange->propertyName(), "layer"); - QCOMPARE(removeChange->subjectId(), layerFilter->id()); - QCOMPARE(removeChange->removedNodeId(), layer->id()); - QCOMPARE(removeChange->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data())); + + arbiter.dirtyNodes.clear(); } void checkLayerBookkeeping() diff --git a/tests/auto/render/qmaterial/tst_qmaterial.cpp b/tests/auto/render/qmaterial/tst_qmaterial.cpp index 5b24c6127..501d50556 100644 --- a/tests/auto/render/qmaterial/tst_qmaterial.cpp +++ b/tests/auto/render/qmaterial/tst_qmaterial.cpp @@ -295,13 +295,9 @@ private Q_SLOTS: QCOMPARE(param->parent(), material); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), param->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(material->parameters().contains(param)); // WHEN (add parameter to effect) param = new Qt3DRender::QParameter("testParamEffect", QVariant::fromValue(383.0f)); @@ -309,13 +305,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), param->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 2); + QVERIFY(material->effect()->parameters().contains(param)); // WHEN (add parameter to technique) param = new Qt3DRender::QParameter("testParamTechnique", QVariant::fromValue(383.0f)); @@ -323,13 +315,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), param->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 3); + QVERIFY(material->m_technique->parameters().contains(param)); - arbiter.events.clear(); // WHEN (add parameter to renderpass) param = new Qt3DRender::QParameter("testParamRenderPass", QVariant::fromValue(383.0f)); @@ -337,13 +326,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), param->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 4); + QVERIFY(material->m_renderPass->parameters().contains(param)); } void checkShaderProgramUpdates() diff --git a/tests/auto/render/qmesh/tst_qmesh.cpp b/tests/auto/render/qmesh/tst_qmesh.cpp index fbc566395..49679e29e 100644 --- a/tests/auto/render/qmesh/tst_qmesh.cpp +++ b/tests/auto/render/qmesh/tst_qmesh.cpp @@ -186,18 +186,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "geometryFactory"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - - Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>(); - QSharedPointer<Qt3DRender::MeshLoaderFunctor> meshFunctor = qSharedPointerCast<Qt3DRender::MeshLoaderFunctor>(factory); - QVERIFY(meshFunctor != nullptr); - QCOMPARE(meshFunctor->mesh(), mesh.id()); - QCOMPARE(meshFunctor->sourcePath(), mesh.source()); - - arbiter.events.clear(); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &mesh); + + arbiter.dirtyNodes.clear(); } { @@ -206,7 +198,7 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); } } @@ -231,18 +223,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "geometryFactory"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - - Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>(); - QSharedPointer<Qt3DRender::MeshLoaderFunctor> meshFunctor = qSharedPointerCast<Qt3DRender::MeshLoaderFunctor>(factory); - QVERIFY(meshFunctor != nullptr); - QCOMPARE(meshFunctor->mesh(), mesh.id()); - QCOMPARE(meshFunctor->meshName(), mesh.meshName()); - - arbiter.events.clear(); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &mesh); + + arbiter.dirtyNodes.clear(); } { @@ -251,7 +235,7 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); } } diff --git a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp index 2fab1e837..b9cb2230f 100644 --- a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp +++ b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp @@ -72,17 +72,11 @@ private Q_SLOTS: QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(QRect(10, 15, 20, 50))); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "renderCaptureRequest"); - QCOMPARE(change->subjectId(),renderCapture->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - QVERIFY(change->value().canConvert<Qt3DRender::QRenderCaptureRequest>()); - const Qt3DRender::QRenderCaptureRequest request = change->value().value<Qt3DRender::QRenderCaptureRequest>(); - QCOMPARE(request.captureId, 1); - QCOMPARE(request.rect, QRect(10, 15, 20, 50)); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), renderCapture.data()); + + arbiter.dirtyNodes.clear(); } void checkRenderCaptureReply() diff --git a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp index 38b66de94..ce9c6581b 100644 --- a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp +++ b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp @@ -338,11 +338,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "filterKeys"); - QCOMPARE(change->addedNodeId(), filterKey.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } @@ -353,11 +351,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "filterKeys"); - QCOMPARE(change->removedNodeId(), filterKey.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } @@ -378,11 +374,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "renderState"); - QCOMPARE(change->addedNodeId(), renderState.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } @@ -393,11 +387,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "renderState"); - QCOMPARE(change->removedNodeId(), renderState.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } @@ -418,11 +410,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } @@ -433,11 +423,9 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->removedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &renderPass); arbiter.events.clear(); } diff --git a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp index 23544c0c6..f08846ba3 100644 --- a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp +++ b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp @@ -154,14 +154,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->subjectId(),renderPassFilter->id()); - QCOMPARE(change->addedNodeId(), param1->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN renderPassFilter->addParameter(param1); @@ -169,20 +166,18 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN renderPassFilter->removeParameter(param1); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "parameter"); - QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id()); - QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey(); @@ -190,14 +185,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "match"); - QCOMPARE(change->subjectId(),renderPassFilter->id()); - QCOMPARE(change->addedNodeId(), filterKey1->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN renderPassFilter->addMatch(filterKey1); @@ -205,20 +197,18 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN renderPassFilter->removeMatch(filterKey1); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "match"); - QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id()); - QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data())); + + arbiter.dirtyNodes.clear(); } void checkParameterBookkeeping() diff --git a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp index 6b200d19d..9eb97ce93 100644 --- a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp +++ b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp @@ -140,14 +140,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "renderState"); - QCOMPARE(change->subjectId(), stateSet->id()); - QCOMPARE(change->addedNodeId(), state1->id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(stateSet.data())); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN stateSet->addRenderState(state1); @@ -155,20 +152,17 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); - + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN stateSet->removeRenderState(state1); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "renderState"); - QCOMPARE(nodeRemovedChange->subjectId(), stateSet->id()); - QCOMPARE(nodeRemovedChange->removedNodeId(), state1->id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(stateSet.data())); + + arbiter.dirtyNodes.clear(); } void checkRenderStateBookkeeping() diff --git a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp index f525f1254..7bacc3b6d 100644 --- a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp +++ b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp @@ -149,14 +149,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "outputs"); - QCOMPARE(change->subjectId(), renderTargetSelector->id()); - QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), outputs); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data()); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); // WHEN renderTargetSelector->setOutputs(outputs); @@ -164,20 +161,18 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN renderTargetSelector->setOutputs(QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>()); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "outputs"); - QCOMPARE(change->subjectId(), renderTargetSelector->id()); - QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>()); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data()); + + arbiter.dirtyNodes.clear(); } void checkRenderTargetBookkeeping() diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp index 7865a5f65..a261d0860 100644 --- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp +++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp @@ -470,6 +470,9 @@ private Q_SLOTS: QCOMPARE(spy.count(), 0); QCOMPARE(arbiter.events.size(), 0); QCOMPARE(log(), logValue); + + // Cleanup + Qt3DCore::QNodePrivate::get(this)->setArbiter(nullptr); } void checkStatusPropertyUpdate() @@ -503,6 +506,9 @@ private Q_SLOTS: QCOMPARE(spy.count(), 0); QCOMPARE(arbiter.events.size(), 0); QCOMPARE(status(), newStatus); + + // Cleanup + Qt3DCore::QNodePrivate::get(this)->setArbiter(nullptr); } void checkIncludes() diff --git a/tests/auto/render/qtechnique/tst_qtechnique.cpp b/tests/auto/render/qtechnique/tst_qtechnique.cpp index 1026dddc0..1e7e4b440 100644 --- a/tests/auto/render/qtechnique/tst_qtechnique.cpp +++ b/tests/auto/render/qtechnique/tst_qtechnique.cpp @@ -329,28 +329,21 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "pass"); - QCOMPARE(change->addedNodeId(), pass.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } - { // WHEN technique.removeRenderPass(&pass); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "pass"); - QCOMPARE(change->removedNodeId(), pass.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); } } @@ -368,13 +361,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->addedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } { @@ -383,13 +374,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "parameter"); - QCOMPARE(change->removedNodeId(), parameter.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } } @@ -407,13 +396,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(change->propertyName(), "filterKeys"); - QCOMPARE(change->addedNodeId(), filterKey.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } { @@ -422,13 +409,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(change->propertyName(), "filterKeys"); - QCOMPARE(change->removedNodeId(), filterKey.id()); - QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } } @@ -445,14 +430,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "graphicsApiFilterData"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>(); - QCOMPARE(data.m_major, 4); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); + + arbiter.dirtyNodes.clear(); } { // WHEN @@ -460,14 +442,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "graphicsApiFilterData"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>(); - QCOMPARE(data.m_minor, 5); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); + + arbiter.dirtyNodes.clear(); } { // WHEN @@ -475,14 +454,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "graphicsApiFilterData"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>(); - QCOMPARE(data.m_vendor, QStringLiteral("AMD")); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); + + arbiter.dirtyNodes.clear(); } { // WHEN @@ -490,14 +466,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "graphicsApiFilterData"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>(); - QCOMPARE(data.m_profile, Qt3DRender::QGraphicsApiFilter::CompatibilityProfile); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QVERIFY(arbiter.dirtyNodes.contains(&technique)); + + arbiter.dirtyNodes.clear(); } } }; diff --git a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp index 4f6daae8c..648fbd5ce 100644 --- a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp +++ b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp @@ -159,14 +159,11 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeAddedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(nodeAddedChange->propertyName(), "parameter"); - QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id()); - QCOMPARE(nodeAddedChange->addedNodeId(), param1->id()); - QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data()); + arbiter.dirtyNodes.clear(); - arbiter.events.clear(); // WHEN techniqueFilter->addParameter(param1); @@ -174,20 +171,17 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN techniqueFilter->removeParameter(param1); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "parameter"); - QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id()); - QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data()); + arbiter.dirtyNodes.clear(); // WHEN Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey(); @@ -195,14 +189,10 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>(); - QCOMPARE(nodeAddedChange->propertyName(), "matchAll"); - QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id()); - QCOMPARE(nodeAddedChange->addedNodeId(), filterKey1->id()); - QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data()); + arbiter.dirtyNodes.clear(); // WHEN techniqueFilter->addMatch(filterKey1); @@ -210,20 +200,17 @@ private Q_SLOTS: // THEN QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); // WHEN techniqueFilter->removeMatch(filterKey1); QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>(); - QCOMPARE(nodeRemovedChange->propertyName(), "matchAll"); - QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id()); - QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id()); - QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved); - - arbiter.events.clear(); + QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data()); + arbiter.dirtyNodes.clear(); } void checkParameterBookkeeping() diff --git a/tests/auto/render/qtextureimage/tst_qtextureimage.cpp b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp index 224784011..8ea656c28 100644 --- a/tests/auto/render/qtextureimage/tst_qtextureimage.cpp +++ b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp @@ -174,14 +174,8 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "dataGenerator"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - - const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(change->value().value<Qt3DRender::QTextureImageDataGeneratorPtr>()); - QVERIFY(generator); - QCOMPARE(generator->url(), textureImage.source()); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &textureImage); arbiter.events.clear(); } @@ -210,14 +204,8 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "dataGenerator"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); - - const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(change->value().value<Qt3DRender::QTextureImageDataGeneratorPtr>()); - QVERIFY(generator); - QCOMPARE(generator->isMirrored(), textureImage.isMirrored()); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &textureImage); arbiter.events.clear(); } diff --git a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp index 56ad55adf..eebbf5d41 100644 --- a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp +++ b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp @@ -168,16 +168,14 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - const auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "generator"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader); - const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(change->value().value<Qt3DRender::QTextureGeneratorPtr>()); + Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader)); + const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor()); QVERIFY(generator); QCOMPARE(generator->url(), QUrl(QStringLiteral("Gary"))); - arbiter.events.clear(); } @@ -205,16 +203,15 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 1); - const auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>(); - QCOMPARE(change->propertyName(), "generator"); - QCOMPARE(change->type(), Qt3DCore::PropertyUpdated); + QCOMPARE(arbiter.dirtyNodes.size(), 1); + QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader); - const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(change->value().value<Qt3DRender::QTextureGeneratorPtr>()); + Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader)); + const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor()); QVERIFY(generator); QCOMPARE(generator->isMirrored(), false); - arbiter.events.clear(); + arbiter.dirtyNodes.clear(); } { @@ -223,7 +220,7 @@ private Q_SLOTS: QCoreApplication::processEvents(); // THEN - QCOMPARE(arbiter.events.size(), 0); + QCOMPARE(arbiter.dirtyNodes.size(), 0); } } diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp index d44596abc..e45ec704e 100644 --- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp +++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp @@ -52,7 +52,6 @@ #include <Qt3DRender/private/updateworldtransformjob_p.h> #include <Qt3DRender/private/expandboundingvolumejob_p.h> #include <Qt3DRender/private/calcboundingvolumejob_p.h> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h> #include <Qt3DRender/private/loadbufferjob_p.h> #include <Qt3DRender/private/buffermanager_p.h> @@ -88,6 +87,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -98,7 +114,7 @@ public: QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes)); Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); @@ -130,10 +146,6 @@ namespace { void runRequiredJobs(Qt3DRender::TestAspect *test) { - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(test->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; updateWorldTransform.setRoot(test->sceneRoot()); updateWorldTransform.setManagers(test->nodeManagers()); diff --git a/tests/auto/render/rendercapture/tst_rendercapture.cpp b/tests/auto/render/rendercapture/tst_rendercapture.cpp index 78b792b01..194c5cd24 100644 --- a/tests/auto/render/rendercapture/tst_rendercapture.cpp +++ b/tests/auto/render/rendercapture/tst_rendercapture.cpp @@ -49,7 +49,7 @@ private Q_SLOTS: // WHEN backend.setRenderer(&renderer); - simulateInitialization(&frontend, &backend); + simulateInitializationSync(&frontend, &backend); // THEN QVERIFY(!backend.peerId().isNull()); @@ -61,34 +61,33 @@ private Q_SLOTS: void checkEnabledPropertyChange() { // GIVEN + Qt3DRender::QRenderCapture frontend; Qt3DRender::Render::RenderCapture renderCapture; TestRenderer renderer; renderCapture.setRenderer(&renderer); + simulateInitializationSync(&frontend, &renderCapture); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId())); - change->setPropertyName(QByteArrayLiteral("enabled")); - change->setValue(QVariant::fromValue(true)); - sceneChangeEvent(&renderCapture, change); + frontend.setEnabled(false); + renderCapture.syncFromFrontEnd(&frontend, false); // THEN - QCOMPARE(renderCapture.isEnabled(), true); + QCOMPARE(renderCapture.isEnabled(), false); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty); } void checkReceiveRenderCaptureRequest() { // GIVEN + Qt3DRender::QRenderCapture frontend; Qt3DRender::Render::RenderCapture renderCapture; TestRenderer renderer; renderCapture.setRenderer(&renderer); - renderCapture.setEnabled(true); + simulateInitializationSync(&frontend, &renderCapture); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId())); - change->setPropertyName(QByteArrayLiteral("renderCaptureRequest")); - change->setValue(QVariant::fromValue(32)); - sceneChangeEvent(&renderCapture, change); + frontend.requestCapture(); + renderCapture.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(renderCapture.wasCaptureRequested(), true); diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp index a823c233a..973192d6a 100644 --- a/tests/auto/render/renderer/tst_renderer.cpp +++ b/tests/auto/render/renderer/tst_renderer.cpp @@ -315,30 +315,6 @@ private Q_SLOTS: renderQueue->reset(); // WHEN - renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityHierarchyDirty, nullptr); - jobs = renderer.renderBinJobs(); - - // THEN - QCOMPARE(jobs.size(), - 1 + // EntityEnabledDirty - 1 + // EntityHierarchyJob - 1 + // WorldTransformJob - 1 + // UpdateWorldBoundingVolume - 1 + // UpdateShaderDataTransform - 1 + // ExpandBoundingVolumeJob - 1 + // UpdateEntityLayersJob - 1 + // updateLevelOfDetailJob - 1 + // syncLoadingJobs - 1 + // updateSkinningPaletteJob - 1 + // cleanupJob - 1 + // sendBufferCaptureJob - singleRenderViewJobCount + - layerCacheJobCount); - - renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - renderQueue->reset(); - - // WHEN renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr); jobs = renderer.renderBinJobs(); @@ -346,7 +322,6 @@ private Q_SLOTS: // and ShaderGathererJob are not added here) QCOMPARE(jobs.size(), 1 + // EntityEnabledDirty - 1 + // EntityHierarchyDirty 1 + // WorldTransformJob 1 + // UpdateWorldBoundingVolume 1 + // UpdateShaderDataTransform diff --git a/tests/auto/render/renderpass/tst_renderpass.cpp b/tests/auto/render/renderpass/tst_renderpass.cpp index a4a2762ba..7be741936 100644 --- a/tests/auto/render/renderpass/tst_renderpass.cpp +++ b/tests/auto/render/renderpass/tst_renderpass.cpp @@ -70,6 +70,7 @@ using namespace Qt3DRender::Render; class tst_RenderRenderPass : public Qt3DCore::QBackendNodeTester { Q_OBJECT + public: tst_RenderRenderPass() : m_renderStateManager(new RenderStateManager()) @@ -96,6 +97,8 @@ private slots: { // GIVEN RenderPass backend; + TestRenderer renderer; + backend.setRenderer(&renderer); // WHEN backend.setEnabled(true); @@ -112,7 +115,7 @@ private slots: frontend.addRenderState(&state); frontend.setShaderProgram(&program); - simulateInitialization(&frontend, &backend); + simulateInitializationSync(&frontend, &backend); } backend.cleanup(); @@ -141,12 +144,14 @@ private slots: frontend.addRenderState(frontendState); RenderPass backend; + TestRenderer renderer; + backend.setRenderer(&renderer); RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id()); - simulateInitialization(frontendState, backendState); + simulateInitializationSync(frontendState, backendState); // WHEN - simulateInitialization(&frontend, &backend); + simulateInitializationSync(&frontend, &backend); // THEN QCOMPARE(backend.shaderProgram(), frontend.shaderProgram()->id()); @@ -165,25 +170,26 @@ private slots: void shouldHandleShaderPropertyChangeEvents() { // GIVEN - QScopedPointer<QShaderProgram> shader(new QShaderProgram); + QShaderProgram *shader = new QShaderProgram; RenderPass backend; TestRenderer renderer; backend.setRenderer(&renderer); + QRenderPass frontend; + simulateInitializationSync(&frontend, &backend); + // WHEN - const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), shader.data()); - addChange->setPropertyName("shaderProgram"); - backend.sceneChangeEvent(addChange); + frontend.setShaderProgram(shader); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.shaderProgram(), shader->id()); QVERIFY(renderer.dirtyBits() != 0); // WHEN - const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), shader.data()); - removeChange->setPropertyName("shaderProgram"); - backend.sceneChangeEvent(removeChange); + frontend.setShaderProgram(nullptr); + backend.syncFromFrontEnd(&frontend, false); // THEN QVERIFY(backend.shaderProgram().isNull()); @@ -192,16 +198,18 @@ private slots: void shouldHandleAnnotationsPropertyChangeEvents() { // GIVEN - QScopedPointer<QFilterKey> annotation(new QFilterKey); + QFilterKey *annotation = new QFilterKey; RenderPass backend; TestRenderer renderer; backend.setRenderer(&renderer); + QRenderPass frontend; + simulateInitializationSync(&frontend, &backend); + // WHEN - const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), annotation.data()); - addChange->setPropertyName("filterKeys"); - backend.sceneChangeEvent(addChange); + frontend.addFilterKey(annotation); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.filterKeys().size(), 1); @@ -209,9 +217,8 @@ private slots: QVERIFY(renderer.dirtyBits() != 0); // WHEN - const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), annotation.data()); - removeChange->setPropertyName("filterKeys"); - backend.sceneChangeEvent(removeChange); + frontend.removeFilterKey(annotation); + backend.syncFromFrontEnd(&frontend, false); // THEN QVERIFY(backend.filterKeys().isEmpty()); @@ -220,16 +227,18 @@ private slots: void shouldHandleParametersPropertyChangeEvents() { // GIVEN - QScopedPointer<QParameter> parameter(new QParameter); + QParameter *parameter = new QParameter; RenderPass backend; TestRenderer renderer; backend.setRenderer(&renderer); + QRenderPass frontend; + simulateInitializationSync(&frontend, &backend); + // WHEN - const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), parameter.data()); - addChange->setPropertyName("parameter"); - backend.sceneChangeEvent(addChange); + frontend.addParameter(parameter); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().size(), 1); @@ -237,9 +246,8 @@ private slots: QVERIFY(renderer.dirtyBits() != 0); // WHEN - const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), parameter.data()); - removeChange->setPropertyName("parameter"); - backend.sceneChangeEvent(removeChange); + frontend.removeParameter(parameter); + backend.syncFromFrontEnd(&frontend, false); // THEN QVERIFY(backend.parameters().isEmpty()); @@ -254,12 +262,14 @@ private slots: backend.setRenderer(&renderer); RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id()); - simulateInitialization(frontendState, backendState); + simulateInitializationSync(frontendState, backendState); + + QRenderPass frontend; + simulateInitializationSync(&frontend, &backend); // WHEN - const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), frontendState); - addChange->setPropertyName("renderState"); - backend.sceneChangeEvent(addChange); + frontend.addRenderState(frontendState); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.renderStates().size(), 1); @@ -267,32 +277,13 @@ private slots: QVERIFY(renderer.dirtyBits() != 0); // WHEN - const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), frontendState); - removeChange->setPropertyName("renderState"); - backend.sceneChangeEvent(removeChange); + frontend.removeRenderState(frontendState); + backend.syncFromFrontEnd(&frontend, false); // THEN QVERIFY(backend.renderStates().isEmpty()); } - void shouldHandleShaderProgramPropertyChangeEvents() - { - // GIVEN - RenderPass backend; - TestRenderer renderer; - backend.setRenderer(&renderer); - - // WHEN - Qt3DCore::QNodeId shaderId = Qt3DCore::QNodeId::createId(); - const auto shaderChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - shaderChange->setPropertyName("shaderProgram"); - shaderChange->setValue(QVariant::fromValue(shaderId)); - backend.sceneChangeEvent(shaderChange); - - // THEN - QCOMPARE(backend.shaderProgram(), shaderId); - } - private: RenderStateManager *m_renderStateManager; }; diff --git a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp index 18c3b3f36..22a461e4a 100644 --- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp +++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp @@ -78,7 +78,12 @@ public: }); for (const auto node: nodes) - d_func()->createBackendNode(node); + d_func()->createBackendNode({ + node->id(), + Qt3DCore::QNodePrivate::get(node)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + node + }); } ~TestAspect() diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp index aef1c3657..f38915bf8 100644 --- a/tests/auto/render/renderviews/tst_renderviews.cpp +++ b/tests/auto/render/renderviews/tst_renderviews.cpp @@ -119,7 +119,7 @@ private Q_SLOTS: // WHEN frontendBarrier.setWaitOperations(barriers); - simulateInitialization(&frontendBarrier, &backendBarrier); + simulateInitializationSync(&frontendBarrier, &backendBarrier); // THEN QCOMPARE(renderView.memoryBarrier(), QMemoryBarrier::None); diff --git a/tests/auto/render/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp index c30400202..f620064ed 100644 --- a/tests/auto/render/scene2d/tst_scene2d.cpp +++ b/tests/auto/render/scene2d/tst_scene2d.cpp @@ -276,7 +276,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer, backendBuffer); + simulateInitializationSync(dataBuffer, backendBuffer); positionAttribute->setBuffer(dataBuffer); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -304,28 +304,28 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource( positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute, backendAttribute); + simulateInitializationSync(positionAttribute, backendAttribute); Attribute *backendTexcoordAttribute = nodeManagers->attributeManager() ->getOrCreateResource(texcoordAttribute->id()); backendTexcoordAttribute->setRenderer(&renderer); - simulateInitialization(texcoordAttribute, backendTexcoordAttribute); + simulateInitializationSync(texcoordAttribute, backendTexcoordAttribute); Geometry *backendGeometry = nodeManagers->geometryManager() ->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager() ->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer, backendRenderer); + simulateInitializationSync(geometryRenderer, backendRenderer); Entity *backendEntity = nodeManagers->renderNodesManager()->getOrCreateResource(entity->id()); backendEntity->setRenderer(&renderer); backendEntity->setNodeManagers(nodeManagers.data()); - simulateInitialization(entity.data(), backendEntity); + simulateInitializationSync(entity.data(), backendEntity); #define PICK_TRIANGLE(tri, v0, v1, v2, uvw) \ new Qt3DRender::QPickTriangleEvent(QPointF(), QVector3D(), QVector3D(), 0.0f, \ diff --git a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp index da420e1ac..4db12136a 100644 --- a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp +++ b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp @@ -185,7 +185,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -202,16 +202,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -254,7 +254,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 2 * 5); @@ -274,7 +274,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -298,20 +298,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -354,7 +354,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -371,16 +371,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -423,7 +423,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 2 * 4); @@ -437,7 +437,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -461,20 +461,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -515,7 +515,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -532,16 +532,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -585,7 +585,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 2 * 4); @@ -599,7 +599,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -623,20 +623,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -679,7 +679,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -696,16 +696,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -747,7 +747,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 4); @@ -761,7 +761,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -785,20 +785,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); diff --git a/tests/auto/render/setfence/tst_setfence.cpp b/tests/auto/render/setfence/tst_setfence.cpp index b70bf548c..92f7a0acc 100644 --- a/tests/auto/render/setfence/tst_setfence.cpp +++ b/tests/auto/render/setfence/tst_setfence.cpp @@ -75,7 +75,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::SetFence backendSetFence; backendSetFence.setRenderer(&renderer); - simulateInitialization(&setFence, &backendSetFence); + simulateInitializationSync(&setFence, &backendSetFence); // THEN QCOMPARE(backendSetFence.isEnabled(), true); @@ -88,7 +88,7 @@ private Q_SLOTS: Qt3DRender::Render::SetFence backendSetFence; setFence.setEnabled(false); backendSetFence.setRenderer(&renderer); - simulateInitialization(&setFence, &backendSetFence); + simulateInitializationSync(&setFence, &backendSetFence); // THEN QCOMPARE(backendSetFence.peerId(), setFence.id()); @@ -101,16 +101,16 @@ private Q_SLOTS: { // GIVEN Qt3DRender::Render::SetFence backendSetFence; + Qt3DRender::QSetFence setFence; TestRenderer renderer; backendSetFence.setRenderer(&renderer); + simulateInitializationSync(&setFence, &backendSetFence); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendSetFence.sceneChangeEvent(change); + setFence.setEnabled(newValue); + backendSetFence.syncFromFrontEnd(&setFence, false); // THEN QCOMPARE(backendSetFence.isEnabled(), newValue); diff --git a/tests/auto/render/skeleton/tst_skeleton.cpp b/tests/auto/render/skeleton/tst_skeleton.cpp index 499bb7cc7..17996470c 100644 --- a/tests/auto/render/skeleton/tst_skeleton.cpp +++ b/tests/auto/render/skeleton/tst_skeleton.cpp @@ -86,7 +86,7 @@ private Q_SLOTS: skeleton.setSource(QUrl::fromLocalFile("funnybones.json")); // WHEN - simulateInitialization(&skeleton, &backendSkeleton); + simulateInitializationSync(&skeleton, &backendSkeleton); // THEN QCOMPARE(backendSkeleton.peerId(), skeleton.id()); @@ -104,7 +104,7 @@ private Q_SLOTS: skeleton2.setRootJoint(joint); // WHEN - simulateInitialization(&skeleton2, &backendSkeleton2); + simulateInitializationSync(&skeleton2, &backendSkeleton2); // THEN QCOMPARE(backendSkeleton2.peerId(), skeleton2.id()); @@ -135,7 +135,7 @@ private Q_SLOTS: skeleton.setSource(QUrl::fromLocalFile("skeleton1.json")); // WHEN - simulateInitialization(&skeleton, &backendSkeleton); + simulateInitializationSync(&skeleton, &backendSkeleton); backendSkeleton.cleanup(); // THEN @@ -145,7 +145,7 @@ private Q_SLOTS: QCOMPARE(backendSkeleton.rootJointId(), QNodeId()); } - void checkPropertyChanges() + void checkDirectPropertyChanges() { // GIVEN TestRenderer renderer; @@ -160,36 +160,22 @@ private Q_SLOTS: // Initialize to ensure skeleton manager is set QSkeletonLoader skeleton; skeleton.setSource(QUrl::fromLocalFile("skeleton1.json")); - simulateInitialization(&skeleton, &backendSkeleton); + simulateInitializationSync(&skeleton, &backendSkeleton); // WHEN - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("enabled"); - updateChange->setValue(true); - backendSkeleton.sceneChangeEvent(updateChange); + skeleton.setEnabled(false); + backendSkeleton.syncFromFrontEnd(&skeleton, false); // THEN - QCOMPARE(backendSkeleton.isEnabled(), true); + QCOMPARE(backendSkeleton.isEnabled(), false); // WHEN const QUrl newSource = QUrl::fromLocalFile("terminator.json"); - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("source"); - updateChange->setValue(newSource); - backendSkeleton.sceneChangeEvent(updateChange); + skeleton.setSource(newSource); + backendSkeleton.syncFromFrontEnd(&skeleton, false); // THEN QCOMPARE(backendSkeleton.source(), newSource); - - // WHEN - const QNodeId newRootJointId = QNodeId::createId(); - updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setPropertyName("rootJoint"); - updateChange->setValue(QVariant::fromValue(newRootJointId)); - backendSkeleton.sceneChangeEvent(updateChange); - - // THEN - QCOMPARE(backendSkeleton.rootJointId(), newRootJointId); } void checkStatusPropertyBackendNotification() diff --git a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp index d79b0b4f7..a4811d82c 100644 --- a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp +++ b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp @@ -70,7 +70,7 @@ private Q_SLOTS: // WHEN backendNode.setRenderer(&renderer); - simulateInitialization(&sortPolicy, &backendNode); + simulateInitializationSync(&sortPolicy, &backendNode); // THEN QCOMPARE(backendNode.peerId(), sortPolicy.id()); @@ -88,15 +88,14 @@ private Q_SLOTS: Qt3DRender::Render::SortPolicy backendNode; backendNode.setRenderer(&renderer); + Qt3DRender::QSortPolicy sortPolicy; + sortPolicy.setSortTypes(sortTypes); + + simulateInitializationSync(&sortPolicy, &backendNode); + // WHEN - auto sortTypeInts = QVector<int>(); - std::transform(sortTypes.constBegin(), sortTypes.constEnd(), - std::back_inserter(sortTypeInts), - [] (Qt3DRender::QSortPolicy::SortType type) -> int { return type; }); - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(QVariant::fromValue(sortTypeInts)); - updateChange->setPropertyName("sortTypes"); - backendNode.sceneChangeEvent(updateChange); + sortPolicy.setSortTypes(sortTypes); + backendNode.syncFromFrontEnd(&sortPolicy, false); // THEN QCOMPARE(backendNode.sortTypes(), sortTypes); diff --git a/tests/auto/render/technique/tst_technique.cpp b/tests/auto/render/technique/tst_technique.cpp index 7d7a0f8ca..64a66f0c8 100644 --- a/tests/auto/render/technique/tst_technique.cpp +++ b/tests/auto/render/technique/tst_technique.cpp @@ -96,7 +96,7 @@ private Q_SLOTS: technique.addParameter(¶meter); technique.addFilterKey(&filterKey); - simulateInitialization(&technique, &backendTechnique); + simulateInitializationSync(&technique, &backendTechnique); } backendTechnique.cleanup(); @@ -129,7 +129,7 @@ private Q_SLOTS: backendTechnique.setRenderer(&renderer); backendTechnique.setNodeManager(&nodeManagers); - simulateInitialization(&technique, &backendTechnique); + simulateInitializationSync(&technique, &backendTechnique); // THEN QCOMPARE(backendTechnique.isEnabled(), true); @@ -157,7 +157,7 @@ private Q_SLOTS: backendTechnique.setNodeManager(&nodeManagers); backendTechnique.setRenderer(&renderer); technique.setEnabled(false); - simulateInitialization(&technique, &backendTechnique); + simulateInitializationSync(&technique, &backendTechnique); // THEN QCOMPARE(backendTechnique.peerId(), technique.id()); @@ -184,6 +184,7 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN + Qt3DRender::QTechnique technique; Qt3DRender::Render::Technique backendTechnique; Qt3DRender::Render::NodeManagers nodeManagers; @@ -193,34 +194,31 @@ private Q_SLOTS: { // WHEN - const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendTechnique.sceneChangeEvent(change); + const bool newValue = true; + technique.setEnabled(newValue); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.isEnabled(), newValue); QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty); renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); + QCOMPARE(nodeManagers.techniqueManager()->takeDirtyTechniques().size(), 1); } { // WHEN backendTechnique.setCompatibleWithRenderer(true); QCOMPARE(nodeManagers.techniqueManager()->takeDirtyTechniques().size(), 0); - Qt3DRender::GraphicsApiFilterData newValue; - newValue.m_major = 4; - newValue.m_minor = 5; - newValue.m_vendor = QStringLiteral("ATI"); + technique.graphicsApiFilter()->setMajorVersion(4); + technique.graphicsApiFilter()->setMinorVersion(5); + technique.graphicsApiFilter()->setVendor(QStringLiteral("ATI")); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("graphicsApiFilterData"); - change->setValue(QVariant::fromValue(newValue)); - backendTechnique.sceneChangeEvent(change); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN - QCOMPARE(*backendTechnique.graphicsApiFilter(), newValue); + QCOMPARE(backendTechnique.graphicsApiFilter()->m_major, technique.graphicsApiFilter()->majorVersion()); + QCOMPARE(backendTechnique.graphicsApiFilter()->m_minor, technique.graphicsApiFilter()->minorVersion()); + QCOMPARE(backendTechnique.graphicsApiFilter()->m_vendor, technique.graphicsApiFilter()->vendor()); QCOMPARE(backendTechnique.isCompatibleWithRenderer(), false); const QVector<Qt3DCore::QNodeId> dirtyTechniques = nodeManagers.techniqueManager()->takeDirtyTechniques(); @@ -235,9 +233,8 @@ private Q_SLOTS: { // WHEN - const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), ¶meter); - change->setPropertyName("parameter"); - backendTechnique.sceneChangeEvent(change); + technique.addParameter(¶meter); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.parameters().size(), 1); @@ -247,9 +244,8 @@ private Q_SLOTS: } { // WHEN - const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), ¶meter); - change->setPropertyName("parameter"); - backendTechnique.sceneChangeEvent(change); + technique.removeParameter(¶meter); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.parameters().size(), 0); @@ -262,9 +258,8 @@ private Q_SLOTS: { // WHEN - const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &filterKey); - change->setPropertyName("filterKeys"); - backendTechnique.sceneChangeEvent(change); + technique.addFilterKey(&filterKey); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.filterKeys().size(), 1); @@ -274,9 +269,8 @@ private Q_SLOTS: } { // WHEN - const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &filterKey); - change->setPropertyName("filterKeys"); - backendTechnique.sceneChangeEvent(change); + technique.removeFilterKey(&filterKey); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.filterKeys().size(), 0); @@ -289,9 +283,8 @@ private Q_SLOTS: { // WHEN - const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &pass); - change->setPropertyName("pass"); - backendTechnique.sceneChangeEvent(change); + technique.addRenderPass(&pass); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.renderPasses().size(), 1); @@ -301,9 +294,8 @@ private Q_SLOTS: } { // WHEN - const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &pass); - change->setPropertyName("pass"); - backendTechnique.sceneChangeEvent(change); + technique.removeRenderPass(&pass); + backendTechnique.syncFromFrontEnd(&technique, false); // THEN QCOMPARE(backendTechnique.renderPasses().size(), 0); diff --git a/tests/auto/render/texture/tst_texture.cpp b/tests/auto/render/texture/tst_texture.cpp index 1d69c54be..a51f082a7 100644 --- a/tests/auto/render/texture/tst_texture.cpp +++ b/tests/auto/render/texture/tst_texture.cpp @@ -244,7 +244,7 @@ void tst_RenderTexture::checkPropertyMirroring() frontend.setSamples(32); // WHEN - simulateInitialization(&frontend, &backend); + simulateInitializationSync(&frontend, &backend); // THEN QCOMPARE(backend.peerId(), frontend.id()); @@ -275,15 +275,14 @@ void tst_RenderTexture::checkPropertyChanges() { // GIVEN TestRenderer renderer; + Qt3DRender::QSharedGLTexture frontend; Qt3DRender::Render::Texture backend; backend.setRenderer(&renderer); backend.unsetDirty(); // WHEN - Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId())); - updateChange->setValue(256); - updateChange->setPropertyName("width"); - backend.sceneChangeEvent(updateChange); + frontend.setWidth(256); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().width, 256); @@ -293,10 +292,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(128); - updateChange->setPropertyName("height"); - backend.sceneChangeEvent(updateChange); + frontend.setHeight(128); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().height, 128); @@ -306,10 +303,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(16); - updateChange->setPropertyName("depth"); - backend.sceneChangeEvent(updateChange); + frontend.setDepth(16); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().depth, 16); @@ -319,10 +314,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::RGB16F)); - updateChange->setPropertyName("format"); - backend.sceneChangeEvent(updateChange); + frontend.setFormat(Qt3DRender::QAbstractTexture::RGB16F); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().format, Qt3DRender::QAbstractTexture::RGB16F); @@ -332,23 +325,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::Target1DArray)); - updateChange->setPropertyName("target"); - backend.sceneChangeEvent(updateChange); - - // THEN - QCOMPARE(backend.properties().target, Qt3DRender::QAbstractTexture::Target1DArray); - QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TexturesDirty); - QVERIFY(backend.dirtyFlags() == Qt3DRender::Render::Texture::DirtyProperties); - renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - backend.unsetDirty(); - - // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(true); - updateChange->setPropertyName("mipmaps"); - backend.sceneChangeEvent(updateChange); + frontend.setGenerateMipMaps(true); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().generateMipMaps, true); @@ -358,10 +336,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::LinearMipMapLinear)); - updateChange->setPropertyName("minificationFilter"); - backend.sceneChangeEvent(updateChange); + frontend.setMinificationFilter(Qt3DRender::QAbstractTexture::LinearMipMapLinear); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().minificationFilter, Qt3DRender::QAbstractTexture::LinearMipMapLinear); @@ -371,10 +347,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::Linear)); - updateChange->setPropertyName("magnificationFilter"); - backend.sceneChangeEvent(updateChange); + frontend.setMagnificationFilter(Qt3DRender::QAbstractTexture::Linear); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().magnificationFilter, Qt3DRender::QAbstractTexture::Linear); @@ -384,10 +358,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat)); - updateChange->setPropertyName("wrapModeX"); - backend.sceneChangeEvent(updateChange); + frontend.wrapMode()->setX(Qt3DRender::QTextureWrapMode::Repeat); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().wrapModeX, Qt3DRender::QTextureWrapMode::Repeat); @@ -397,10 +369,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat)); - updateChange->setPropertyName("wrapModeY"); - backend.sceneChangeEvent(updateChange); + frontend.wrapMode()->setY(Qt3DRender::QTextureWrapMode::Repeat); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().wrapModeY, Qt3DRender::QTextureWrapMode::Repeat); @@ -410,10 +380,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat)); - updateChange->setPropertyName("wrapModeZ"); - backend.sceneChangeEvent(updateChange); + frontend.wrapMode()->setZ(Qt3DRender::QTextureWrapMode::Repeat); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().wrapModeZ, Qt3DRender::QTextureWrapMode::Repeat); @@ -423,10 +391,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(16.0f); - updateChange->setPropertyName("maximumAnisotropy"); - backend.sceneChangeEvent(updateChange); + frontend.setMaximumAnisotropy(16.f); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().maximumAnisotropy, 16.0f); @@ -436,10 +402,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::CompareEqual)); - updateChange->setPropertyName("comparisonFunction"); - backend.sceneChangeEvent(updateChange); + frontend.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareEqual); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().comparisonFunction, Qt3DRender::QAbstractTexture::CompareEqual); @@ -449,10 +413,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::CompareRefToTexture)); - updateChange->setPropertyName("comparisonMode"); - backend.sceneChangeEvent(updateChange); + frontend.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.parameters().comparisonMode, Qt3DRender::QAbstractTexture::CompareRefToTexture); @@ -462,10 +424,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(32); - updateChange->setPropertyName("layers"); - backend.sceneChangeEvent(updateChange); + frontend.setLayers(32); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().layers, 32); @@ -475,10 +435,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(64); - updateChange->setPropertyName("samples"); - backend.sceneChangeEvent(updateChange); + frontend.setSamples(64); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.properties().samples, 64); @@ -488,24 +446,8 @@ void tst_RenderTexture::checkPropertyChanges() backend.unsetDirty(); // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - Qt3DRender::QTextureGeneratorPtr gen = QSharedPointer<FakeGenerator>::create(); - updateChange->setValue(QVariant::fromValue(gen)); - updateChange->setPropertyName("generator"); - backend.sceneChangeEvent(updateChange); - - // THEN - QCOMPARE(backend.dataGenerator(), gen); - QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TexturesDirty); - QVERIFY(backend.dirtyFlags() == Qt3DRender::Render::Texture::DirtyDataGenerator); - renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); - backend.unsetDirty(); - - // WHEN - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setValue(883); - updateChange->setPropertyName("textureId"); - backend.sceneChangeEvent(updateChange); + frontend.setTextureId(883); + backend.syncFromFrontEnd(&frontend, false); // THEN QCOMPARE(backend.sharedTextureId(), 883); @@ -533,10 +475,8 @@ void tst_RenderTexture::checkPropertyChanges() updateData.setX(100); updateData.setY(100); updateData.setZ(100); - updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId()); - updateChange->setPropertyName("updateData"); - updateChange->setValue(QVariant::fromValue(updateData)); - backend.sceneChangeEvent(updateChange); + frontend.updateData(updateData); + backend.syncFromFrontEnd(&frontend, false); // THEN const QVector<Qt3DRender::QTextureDataUpdate> pendingUpdates = backend.takePendingTextureDataUpdates(); @@ -589,7 +529,7 @@ void tst_RenderTexture::checkInitialUpdateData() // WHEN -> updateData with no backend/arbiter frontend.updateData(updateData); - simulateInitialization(&frontend, &backend); + simulateInitializationSync(&frontend, &backend); // THEN -> should have received the update as part of the initial data const QVector<Qt3DRender::QTextureDataUpdate> pendingUpdates = backend.takePendingTextureDataUpdates(); diff --git a/tests/auto/render/transform/tst_transform.cpp b/tests/auto/render/transform/tst_transform.cpp index 8e4ab8ef0..3238da2fe 100644 --- a/tests/auto/render/transform/tst_transform.cpp +++ b/tests/auto/render/transform/tst_transform.cpp @@ -59,6 +59,7 @@ private Q_SLOTS: // GIVEN TestRenderer renderer; Qt3DRender::Render::Transform backendTransform; + backendTransform.setRenderer(&renderer); // WHEN { @@ -67,7 +68,7 @@ private Q_SLOTS: transform.setTranslation(QVector3D(-1.0, 5.0f, -2.0f)); transform.setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1.0f, 0.0f, 0.0), 30.0f)); backendTransform.setRenderer(&renderer); - simulateInitialization(&transform, &backendTransform); + simulateInitializationSync(&transform, &backendTransform); } backendTransform.setEnabled(true); @@ -94,7 +95,9 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::Transform backendTransform; backendTransform.setRenderer(&renderer); - simulateInitialization(&transform, &backendTransform); + TestRenderer renderer; + backendTransform.setRenderer(&renderer); + simulateInitializationSync(&transform, &backendTransform); // THEN QCOMPARE(backendTransform.isEnabled(), true); @@ -109,9 +112,10 @@ private Q_SLOTS: { // WHEN Qt3DRender::Render::Transform backendTransform; + TestRenderer renderer; backendTransform.setRenderer(&renderer); transform.setEnabled(false); - simulateInitialization(&transform, &backendTransform); + simulateInitializationSync(&transform, &backendTransform); // THEN QCOMPARE(backendTransform.peerId(), transform.id()); @@ -123,17 +127,18 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN + Qt3DCore::QTransform frontendTranform; Qt3DRender::Render::Transform backendTransform; TestRenderer renderer; backendTransform.setRenderer(&renderer); + backendTransform.syncFromFrontEnd(&frontendTranform, true); + renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendTransform.sceneChangeEvent(change); + frontendTranform.setEnabled(newValue); + backendTransform.syncFromFrontEnd(&frontendTranform, false); // THEN QCOMPARE(backendTransform.isEnabled(), newValue); @@ -143,10 +148,8 @@ private Q_SLOTS: { // WHEN const QQuaternion newValue = QQuaternion::fromAxisAndAngle(QVector3D(0.0f, 1.0f, 0.0f), 45.0f); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("rotation"); - change->setValue(QVariant::fromValue(newValue)); - backendTransform.sceneChangeEvent(change); + frontendTranform.setRotation(newValue); + backendTransform.syncFromFrontEnd(&frontendTranform, false); // THEN QCOMPARE(backendTransform.rotation(), newValue); @@ -156,10 +159,8 @@ private Q_SLOTS: { // WHEN const QVector3D newValue(454.0f, 355.0f, 0.0f); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("scale3D"); - change->setValue(QVariant::fromValue(newValue)); - backendTransform.sceneChangeEvent(change); + frontendTranform.setScale3D(newValue); + backendTransform.syncFromFrontEnd(&frontendTranform, false); // THEN QCOMPARE(backendTransform.scale(), newValue); @@ -169,10 +170,8 @@ private Q_SLOTS: { // WHEN const QVector3D newValue(383.0f, 0.0f, 427.0f); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("translation"); - change->setValue(QVariant::fromValue(newValue)); - backendTransform.sceneChangeEvent(change); + frontendTranform.setTranslation(newValue); + backendTransform.syncFromFrontEnd(&frontendTranform, false); // THEN QCOMPARE(backendTransform.translation(), newValue); diff --git a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp index 0c3b579de..287a17b84 100644 --- a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp +++ b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp @@ -320,16 +320,21 @@ public: TestAspect(Qt3DCore::QNode *root) : Qt3DRender::QRenderAspect() { - QVector<Qt3DCore::QNode *> nodes; + QVector<Qt3DCore::NodeTreeChange> nodes; Qt3DCore::QNodeVisitor v; v.traverse(root, [&nodes](Qt3DCore::QNode *node) { Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(node); d->m_typeInfo = const_cast<QMetaObject*>(Qt3DCore::QNodePrivate::findStaticMetaObject(node->metaObject())); d->m_hasBackendNode = true; - nodes << node; + nodes.push_back({ + node->id(), + Qt3DCore::QNodePrivate::get(node)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + node + }); }); - for (const auto node: nodes) + for (const auto &node: nodes) d_func()->createBackendNode(node); } diff --git a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp index 4205d598e..8dfda0eea 100644 --- a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp +++ b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp @@ -187,7 +187,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -204,16 +204,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -262,7 +262,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 3 * 5); @@ -287,7 +287,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -311,20 +311,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -374,7 +374,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -391,16 +391,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -451,7 +451,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 3 * 4); @@ -473,7 +473,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -497,20 +497,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -563,7 +563,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -580,16 +580,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -640,7 +640,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 3 * 2); @@ -656,7 +656,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -680,20 +680,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -742,7 +742,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -759,16 +759,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -816,7 +816,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 3 * 4); @@ -839,7 +839,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -863,20 +863,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -936,7 +936,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -953,16 +953,16 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); @@ -1012,7 +1012,7 @@ private Q_SLOTS: Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id()); backendBuffer->setRenderer(&renderer); backendBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(dataBuffer.data(), backendBuffer); + simulateInitializationSync(dataBuffer.data(), backendBuffer); QByteArray indexData; indexData.resize(sizeof(uint) * 8); @@ -1030,7 +1030,7 @@ private Q_SLOTS: Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id()); backendIndexBuffer->setRenderer(&renderer); backendIndexBuffer->setManager(nodeManagers->bufferManager()); - simulateInitialization(indexDataBuffer.data(), backendIndexBuffer); + simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer); positionAttribute->setBuffer(dataBuffer.data()); positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName()); @@ -1054,20 +1054,20 @@ private Q_SLOTS: Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id()); backendAttribute->setRenderer(&renderer); - simulateInitialization(positionAttribute.data(), backendAttribute); + simulateInitializationSync(positionAttribute.data(), backendAttribute); Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id()); backendIndexAttribute->setRenderer(&renderer); - simulateInitialization(indexAttribute.data(), backendIndexAttribute); + simulateInitializationSync(indexAttribute.data(), backendIndexAttribute); Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id()); backendGeometry->setRenderer(&renderer); - simulateInitialization(geometry, backendGeometry); + simulateInitializationSync(geometry, backendGeometry); GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id()); backendRenderer->setRenderer(&renderer); backendRenderer->setManager(nodeManagers->geometryRendererManager()); - simulateInitialization(geometryRenderer.data(), backendRenderer); + simulateInitializationSync(geometryRenderer.data(), backendRenderer); // WHEN visitor.apply(backendRenderer, Qt3DCore::QNodeId()); diff --git a/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp b/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp index 71576d495..df24a5ca6 100644 --- a/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp +++ b/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp @@ -69,6 +69,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -79,7 +96,7 @@ public: Qt3DRender::QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes)); Qt3DRender::Render::Entity *rootEntity = nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp index 4fe1794dc..492aa0fde 100644 --- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp +++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp @@ -29,7 +29,6 @@ #include <QtTest/QTest> #include <Qt3DRender/private/updateshaderdatatransformjob_p.h> #include <Qt3DRender/private/updateworldtransformjob_p.h> -#include <Qt3DRender/private/updateentityhierarchyjob_p.h> #include <Qt3DRender/private/nodemanagers_p.h> #include <Qt3DRender/private/managers_p.h> #include <Qt3DRender/qrenderaspect.h> @@ -70,6 +69,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root) return nodes; } +QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes) +{ + QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges; + nodeTreeChanges.reserve(nodes.size()); + + for (Qt3DCore::QNode *n : nodes) { + nodeTreeChanges.push_back({ + n->id(), + Qt3DCore::QNodePrivate::get(n)->m_typeInfo, + Qt3DCore::NodeTreeChange::Added, + n + }); + } + + return nodeTreeChanges; +} + class TestAspect : public Qt3DRender::QRenderAspect { public: @@ -80,7 +96,7 @@ public: Qt3DRender::QRenderAspect::onRegistered(); const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root); - d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes); + d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes)); Qt3DRender::Render::Entity *rootEntity = nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Render::EntityManager>(rootEntityId()); Q_ASSERT(rootEntity); @@ -112,10 +128,6 @@ namespace { void runRequiredJobs(Qt3DRender::TestAspect *test) { - Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob; - updateEntitiesJob.setManager(test->nodeManagers()); - updateEntitiesJob.run(); - Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform; updateWorldTransform.setRoot(test->sceneRoot()); updateWorldTransform.setManagers(test->nodeManagers()); diff --git a/tests/auto/render/waitfence/tst_waitfence.cpp b/tests/auto/render/waitfence/tst_waitfence.cpp index e8cd4c30b..e27e4ae19 100644 --- a/tests/auto/render/waitfence/tst_waitfence.cpp +++ b/tests/auto/render/waitfence/tst_waitfence.cpp @@ -82,7 +82,7 @@ private Q_SLOTS: // WHEN Qt3DRender::Render::WaitFence backendWaitFence; backendWaitFence.setRenderer(&renderer); - simulateInitialization(&waitFence, &backendWaitFence); + simulateInitializationSync(&waitFence, &backendWaitFence); // THEN QCOMPARE(backendWaitFence.isEnabled(), true); @@ -99,7 +99,7 @@ private Q_SLOTS: Qt3DRender::Render::WaitFence backendWaitFence; waitFence.setEnabled(false); backendWaitFence.setRenderer(&renderer); - simulateInitialization(&waitFence, &backendWaitFence); + simulateInitializationSync(&waitFence, &backendWaitFence); // THEN QCOMPARE(backendWaitFence.peerId(), waitFence.id()); @@ -115,17 +115,17 @@ private Q_SLOTS: void checkSceneChangeEvents() { // GIVEN + Qt3DRender::QWaitFence waitFence; Qt3DRender::Render::WaitFence backendWaitFence; TestRenderer renderer; backendWaitFence.setRenderer(&renderer); + simulateInitializationSync(&waitFence, &backendWaitFence); { // WHEN const bool newValue = false; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("enabled"); - change->setValue(newValue); - backendWaitFence.sceneChangeEvent(change); + waitFence.setEnabled(newValue); + backendWaitFence.syncFromFrontEnd(&waitFence, false); // THEN QCOMPARE(backendWaitFence.isEnabled(), newValue); @@ -135,10 +135,8 @@ private Q_SLOTS: { // WHEN const QVariant newValue(984); - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("handle"); - change->setValue(QVariant::fromValue(newValue)); - backendWaitFence.sceneChangeEvent(change); + waitFence.setHandle(newValue); + backendWaitFence.syncFromFrontEnd(&waitFence, false); // THEN QCOMPARE(backendWaitFence.data().handle, QVariant(984)); @@ -148,10 +146,8 @@ private Q_SLOTS: { // WHEN const Qt3DRender::QWaitFence::HandleType newValue = Qt3DRender::QWaitFence::OpenGLFenceId; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("handleType"); - change->setValue(QVariant::fromValue(newValue)); - backendWaitFence.sceneChangeEvent(change); + waitFence.setHandleType(newValue); + backendWaitFence.syncFromFrontEnd(&waitFence, false); // THEN QCOMPARE(backendWaitFence.data().handleType, Qt3DRender::QWaitFence::OpenGLFenceId); @@ -161,10 +157,8 @@ private Q_SLOTS: { // WHEN const bool newValue = true; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("waitOnCPU"); - change->setValue(QVariant::fromValue(newValue)); - backendWaitFence.sceneChangeEvent(change); + waitFence.setWaitOnCPU(newValue); + backendWaitFence.syncFromFrontEnd(&waitFence, false); // THEN QCOMPARE(backendWaitFence.data().waitOnCPU, true); @@ -174,10 +168,8 @@ private Q_SLOTS: { // WHEN const quint64 newValue = 984; - const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId()); - change->setPropertyName("timeout"); - change->setValue(QVariant::fromValue(newValue)); - backendWaitFence.sceneChangeEvent(change); + waitFence.setTimeout(newValue); + backendWaitFence.syncFromFrontEnd(&waitFence, false); // THEN QCOMPARE(backendWaitFence.data().timeout, quint64(984)); |