Update sendTextureChangesToFrontend to use direct sync

Change-Id: I9356186ca27518c32ae189d7e432969b767612e9
Reviewed-by: Mike Krus <mike.krus@kdab.com>

8 files changed, 112 insertions, 94 deletions

diff --git a/src/render/jobs/genericlambdajob_p.h b/src/render/jobs/genericlambdajob_p.h
index d72975761..4d93f0f8d 100644
--- a/src/render/jobs/genericlambdajob_p.h
+++ b/src/render/jobs/genericlambdajob_p.h
@@ -84,6 +84,49 @@ private:
 template<typename T>
 using GenericLambdaJobPtr = QSharedPointer<GenericLambdaJob<T>>;
 
+template<typename T, typename U>
+class GenericLambdaJobAndPostFramePrivate : public Qt3DCore::QAspectJobPrivate
+{
+public:
+    explicit GenericLambdaJobAndPostFramePrivate(U postFrameCallable)
+        : m_postFrameCallable(postFrameCallable)
+    {}
+
+    ~GenericLambdaJobAndPostFramePrivate() override {}
+
+    void postFrame(Qt3DCore::QAspectManager *manager) override
+    {
+        m_postFrameCallable(manager);
+    }
+
+private:
+    U m_postFrameCallable;
+};
+
+template<typename T, typename U>
+class GenericLambdaJobAndPostFrame : public Qt3DCore::QAspectJob
+{
+public:
+    explicit GenericLambdaJobAndPostFrame(T runCallable, U postFrameCallable, JobTypes::JobType type = JobTypes::GenericLambda)
+        : Qt3DCore::QAspectJob(*new GenericLambdaJobAndPostFramePrivate<T, U>(postFrameCallable))
+        , m_runCallable(runCallable)
+    {
+        SET_JOB_RUN_STAT_TYPE(this, type, 0);
+    }
+
+    // QAspectJob interface
+    void run() final
+    {
+        m_runCallable();
+    }
+
+private:
+    T m_runCallable;
+};
+
+template<typename T, typename U>
+using GenericLambdaJobAndPostFramePtr = QSharedPointer<GenericLambdaJobAndPostFrame<T, U>>;
+
 } // Render
 
 } // Qt3DRender
diff --git a/src/render/renderers/opengl/renderer/renderer.cpp b/src/render/renderers/opengl/renderer/renderer.cpp
index 45f13c424..9d9a448f8 100644
--- a/src/render/renderers/opengl/renderer/renderer.cpp
+++ b/src/render/renderers/opengl/renderer/renderer.cpp
@@ -97,6 +97,7 @@
 #include <Qt3DRender/qcameralens.h>
 #include <Qt3DCore/private/qeventfilterservice_p.h>
 #include <Qt3DCore/private/qabstractaspectjobmanager_p.h>
+#include <Qt3DCore/private/qaspectmanager_p.h>
 
 #if QT_CONFIG(qt3d_profile_jobs)
 #include <Qt3DCore/private/aspectcommanddebugger_p.h>
@@ -196,7 +197,9 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     , m_bufferGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForDirtyBuffers(); }, JobTypes::DirtyBufferGathering))
     , m_vaoGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForAbandonedVaos(); }, JobTypes::DirtyVaoGathering))
     , m_textureGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForDirtyTextures(); }, JobTypes::DirtyTextureGathering))
-    , m_sendTextureChangesToFrontendJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { sendTextureChangesToFrontend(); }, JobTypes::SendTextureChangesToFrontend))
+    , m_sendTextureChangesToFrontendJob(decltype(m_sendTextureChangesToFrontendJob)::create([] {},
+                                                                                            [this] (Qt3DCore::QAspectManager *m) { sendTextureChangesToFrontend(m); },
+                                                                                            JobTypes::SendTextureChangesToFrontend))
     , m_sendSetFenceHandlesToFrontendJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { sendSetFenceHandlesToFrontend(); }, JobTypes::SendSetFenceHandlesToFrontend))
     , m_sendDisablesToFrontendJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { sendDisablesToFrontend(); }, JobTypes::SendDisablesToFrontend))
     , m_introspectShaderJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { reloadDirtyShaders(); }, JobTypes::DirtyShaderGathering))
@@ -1167,24 +1170,39 @@ void Renderer::reloadDirtyShaders()
     }
 }
 
-// Executed in a job
-void Renderer::sendTextureChangesToFrontend()
+// Executed in a job (as postFrame)
+void Renderer::sendTextureChangesToFrontend(Qt3DCore::QAspectManager *manager)
 {
     const QVector<QPair<Texture::TextureUpdateInfo, Qt3DCore::QNodeIdVector>> updateTextureProperties = std::move(m_updatedTextureProperties);
     for (const auto &pair : updateTextureProperties) {
-        // Prepare change notification
-
         const Qt3DCore::QNodeIdVector targetIds = pair.second;
         for (const Qt3DCore::QNodeId targetId: targetIds) {
+
             // Lookup texture
             Texture *t = m_nodesManager->textureManager()->lookupResource(targetId);
+            // If backend texture is Dirty, some property has changed and the properties we are
+            // about to send are already outdate
+            if (t == nullptr || t->dirtyFlags() != Texture::NotDirty)
+                continue;
 
-            // Texture might have been deleted between previous and current frame
-            if (t == nullptr)
+            QAbstractTexture *texture = static_cast<QAbstractTexture *>(manager->lookupNode(targetId));
+            if (!texture)
                 continue;
+           const TextureProperties &properties = pair.first.properties;
+
+           const bool blocked = texture->blockNotifications(true);
+           texture->setWidth(properties.width);
+           texture->setHeight(properties.height);
+           texture->setDepth(properties.depth);
+           texture->setLayers(properties.layers);
+           texture->setFormat(properties.format);
+           texture->blockNotifications(blocked);
+
+           QAbstractTexturePrivate *dTexture = static_cast<QAbstractTexturePrivate *>(QNodePrivate::get(texture));
 
-            // Send change and update backend
-            t->updatePropertiesAndNotify(pair.first);
+           dTexture->setStatus(properties.status);
+           dTexture->setHandleType(pair.first.handleType);
+           dTexture->setHandle(pair.first.handle);
         }
     }
 }
diff --git a/src/render/renderers/opengl/renderer/renderer_p.h b/src/render/renderers/opengl/renderer/renderer_p.h
index c7b4f8805..72739caaf 100644
--- a/src/render/renderers/opengl/renderer/renderer_p.h
+++ b/src/render/renderers/opengl/renderer/renderer_p.h
@@ -379,7 +379,7 @@ private:
     GenericLambdaJobPtr<std::function<void ()>> m_bufferGathererJob;
     GenericLambdaJobPtr<std::function<void ()>> m_vaoGathererJob;
     GenericLambdaJobPtr<std::function<void ()>> m_textureGathererJob;
-    GenericLambdaJobPtr<std::function<void ()>> m_sendTextureChangesToFrontendJob;
+    GenericLambdaJobAndPostFramePtr<std::function<void ()>, std::function<void (Qt3DCore::QAspectManager *)>> m_sendTextureChangesToFrontendJob;
     GenericLambdaJobPtr<std::function<void ()>> m_sendSetFenceHandlesToFrontendJob;
     GenericLambdaJobPtr<std::function<void ()>> m_sendDisablesToFrontendJob;
     IntrospectShadersJobPtr m_introspectShaderJob;
@@ -391,7 +391,7 @@ private:
     void lookForDownloadableBuffers();
     void lookForDirtyTextures();
     void reloadDirtyShaders();
-    void sendTextureChangesToFrontend();
+    void sendTextureChangesToFrontend(Qt3DCore::QAspectManager *manager);
     void sendSetFenceHandlesToFrontend();
     void sendDisablesToFrontend();
 
diff --git a/src/render/texture/qabstracttexture.cpp b/src/render/texture/qabstracttexture.cpp
index 229d773ad..46b8d1587 100644
--- a/src/render/texture/qabstracttexture.cpp
+++ b/src/render/texture/qabstracttexture.cpp
@@ -85,6 +85,39 @@ void QAbstractTexturePrivate::setDataFunctor(const QTextureGeneratorPtr &generat
     }
 }
 
+void QAbstractTexturePrivate::setStatus(QAbstractTexture::Status status)
+{
+    Q_Q(QAbstractTexture);
+    if (m_status != status) {
+        m_status = status;
+        const bool blocked = q->blockNotifications(true);
+        q->statusChanged(status);
+        q->blockNotifications(blocked);
+    }
+}
+
+void QAbstractTexturePrivate::setHandle(const QVariant &handle)
+{
+    Q_Q(QAbstractTexture);
+    if (m_handle != handle) {
+        m_handle = handle;
+        const bool blocked = q->blockNotifications(true);
+        emit q->handleChanged(handle);
+        q->blockNotifications(blocked);
+    }
+}
+
+void QAbstractTexturePrivate::setHandleType(QAbstractTexture::HandleType type)
+{
+    Q_Q(QAbstractTexture);
+    if (m_handleType != type) {
+        m_handleType = type;
+        const bool blocked = q->blockNotifications(true);
+        emit q->handleTypeChanged(type);
+        q->blockNotifications(blocked);
+    }
+}
+
 /*!
     \class Qt3DRender::QAbstractTexture
     \inmodule Qt3DRender
@@ -564,7 +597,9 @@ void QAbstractTexture::setStatus(Status status)
     Q_D(QAbstractTexture);
     if (status != d->m_status) {
         d->m_status = status;
+        const bool blocked = blockNotifications(true);
         emit statusChanged(status);
+        blockNotifications(blocked);
     }
 }
 
diff --git a/src/render/texture/qabstracttexture.h b/src/render/texture/qabstracttexture.h
index 5a32b8487..b3d5efb34 100644
--- a/src/render/texture/qabstracttexture.h
+++ b/src/render/texture/qabstracttexture.h
@@ -350,6 +350,7 @@ protected:
     explicit QAbstractTexture(QAbstractTexturePrivate &dd, Qt3DCore::QNode *parent = nullptr);
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override;
 
+    // TO DO Qt6, should be on private class
     void setStatus(Status status);
     void setHandle(const QVariant &handle);
     void setHandleType(HandleType type);
diff --git a/src/render/texture/qabstracttexture_p.h b/src/render/texture/qabstracttexture_p.h
index 573eac8c7..5b2945f73 100644
--- a/src/render/texture/qabstracttexture_p.h
+++ b/src/render/texture/qabstracttexture_p.h
@@ -96,6 +96,10 @@ public :
     QTextureGeneratorPtr dataFunctor() const;
     void setDataFunctor(const QTextureGeneratorPtr &generator);
 
+    void setStatus(QAbstractTexture::Status status);
+    void setHandle(const QVariant &handle);
+    void setHandleType(QAbstractTexture::HandleType type);
+
     QVector<QTextureDataUpdate> m_pendingDataUpdates;
 
 private:
diff --git a/src/render/texture/texture.cpp b/src/render/texture/texture.cpp
index 53216d27d..13f5eae16 100644
--- a/src/render/texture/texture.cpp
+++ b/src/render/texture/texture.cpp
@@ -220,88 +220,6 @@ void Texture::setDataGenerator(const QTextureGeneratorPtr &generator)
     addDirtyFlag(DirtyDataGenerator);
 }
 
-// Called by sendTextureChangesToFrontendJob once GLTexture and sharing
-// has been performed
-void Texture::updatePropertiesAndNotify(const TextureUpdateInfo &updateInfo)
-{
-    // If we are Dirty, some property has changed and the properties we have
-    // received are potentially already outdated
-    if (m_dirty != NotDirty)
-        return;
-
-    // Note we don't update target has it is constant for frontend nodes
-
-    if (updateInfo.properties.width != m_properties.width) {
-        m_properties.width = updateInfo.properties.width;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("width");
-        change->setValue(updateInfo.properties.width);
-        notifyObservers(change);
-    }
-
-    if (updateInfo.properties.height != m_properties.height) {
-        m_properties.height = updateInfo.properties.height;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("height");
-        change->setValue(updateInfo.properties.height);
-        notifyObservers(change);
-    }
-
-    if (updateInfo.properties.depth != m_properties.depth) {
-        m_properties.depth = updateInfo.properties.depth;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("depth");
-        change->setValue(updateInfo.properties.depth);
-        notifyObservers(change);
-    }
-
-    if (updateInfo.properties.layers != m_properties.layers) {
-        m_properties.layers = updateInfo.properties.layers;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("layers");
-        change->setValue(updateInfo.properties.layers);
-        notifyObservers(change);
-    }
-
-    if (updateInfo.properties.format != m_properties.format) {
-        m_properties.format = updateInfo.properties.format;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("format");
-        change->setValue(updateInfo.properties.format);
-        notifyObservers(change);
-    }
-
-    if (updateInfo.properties.status != m_properties.status) {
-        m_properties.status = updateInfo.properties.status;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("status");
-        change->setValue(updateInfo.properties.status);
-        notifyObservers(change);
-    }
-
-    {
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("handleType");
-        change->setValue(updateInfo.handleType);
-        notifyObservers(change);
-    }
-
-    {
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
-        change->setDeliveryFlags(Qt3DCore::QSceneChange::Nodes);
-        change->setPropertyName("handle");
-        change->setValue(updateInfo.handle);
-        notifyObservers(change);
-    }
-}
-
 bool Texture::isValid(TextureImageManager *manager) const
 {
     for (const QNodeId &id : m_textureImageIds) {
diff --git a/src/render/texture/texture_p.h b/src/render/texture/texture_p.h
index 967b2a44a..9f7237342 100644
--- a/src/render/texture/texture_p.h
+++ b/src/render/texture/texture_p.h
@@ -173,7 +173,6 @@ public:
     inline int sharedTextureId() const { return m_sharedTextureId; }
 
     void setDataGenerator(const QTextureGeneratorPtr &generator);
-    void updatePropertiesAndNotify(const TextureUpdateInfo &updateInfo);
     bool isValid(TextureImageManager *manager) const;
 private:
     void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;