Clean up buffer loading in Dragon render aspect

- Remove commented-out code, comments, and TODOs.
- Remove references to async loading, which might however be implemented
later.
- Add warnings when features that are not available in Dragon are used.

Change-Id: I1d2dcffc15438a2c3ba96fd928f19d5d0c436899
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

3 files changed, 25 insertions, 80 deletions

diff --git a/src/runtime/dragon/geometry/dragonbuffer.cpp b/src/runtime/dragon/geometry/dragonbuffer.cpp
index 529e0f4..0a97150 100644
--- a/src/runtime/dragon/geometry/dragonbuffer.cpp
+++ b/src/runtime/dragon/geometry/dragonbuffer.cpp
@@ -30,6 +30,8 @@
 
 #include "dragonbuffer_p.h"
 
+#include <private/dragoncomparegenerators_p.h>
+
 #include <Qt3DCore/qpropertyupdatedchange.h>
 
 QT_BEGIN_NAMESPACE
@@ -45,30 +47,11 @@ void Buffer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chang
     const auto &data = typedChange->data;
     m_data = data.data;
     m_usage = data.usage;
-    m_syncData = data.syncData;
     m_access = data.access;
-    m_bufferDirty = true;
-
-    //    if (!m_data.isEmpty())
-    //        forceDataUpload();
-
     m_generator = data.functor;
-    //    Q_ASSERT(m_manager);
-    //    if (m_functor)
-    //        m_manager->addDirtyBuffer(peerId());
-
-    //    m_manager->addBufferReference(peerId());
-    //    markDirty(AbstractRenderer::BuffersDirty);
-}
-
-bool Buffer::isAsynchronous() const
-{
-    return m_isAsynchronous;
-}
 
-QBufferDataGeneratorPtr Buffer::generator() const
-{
-    return m_generator;
+    if (data.syncData)
+        qWarning() << "WARNING: Dragon render aspect does not yet support syncData. Data on frontend node will not be updated.";
 }
 
 void Buffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
@@ -77,41 +60,36 @@ void Buffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
         QByteArray propertyName = propertyChange->propertyName();
         if (propertyName == QByteArrayLiteral("data")) {
-            QByteArray newData = propertyChange->value().toByteArray();
-            bool dirty = m_data != newData;
-            m_bufferDirty |= dirty;
-            m_data = newData;
+            m_data = propertyChange->value().toByteArray();
             markDirty();
         } else if (propertyName == QByteArrayLiteral("updateData")) {
-            Qt3DRender::QBufferUpdate updateData =
-                propertyChange->value().value<Qt3DRender::QBufferUpdate>();
-            m_bufferUpdates.push_back(updateData);
-            m_bufferDirty = true;
+            qWarning() << "WARNING: Dragon render aspect does not yet support updateData. Buffer data will not be updated.";
             markDirty();
         } else if (propertyName == QByteArrayLiteral("usage")) {
             m_usage = static_cast<QBuffer::UsageType>(propertyChange->value().value<int>());
-            m_bufferDirty = true;
             markDirty();
         } else if (propertyName == QByteArrayLiteral("accessType")) {
             m_access = static_cast<QBuffer::AccessType>(propertyChange->value().value<int>());
             markDirty();
         } else if (propertyName == QByteArrayLiteral("dataGenerator")) {
-            QBufferDataGeneratorPtr newGenerator =
-                propertyChange->value().value<QBufferDataGeneratorPtr>();
-            m_bufferDirty |= !(newGenerator && m_generator && *newGenerator == *m_generator);
+            QBufferDataGeneratorPtr newGenerator = propertyChange->value().value<QBufferDataGeneratorPtr>();
             m_generator = newGenerator;
             markDirty();
-            //            if (m_functor && m_manager != nullptr)
-            //                m_manager->addDirtyBuffer(peerId());
         } else if (propertyName == QByteArrayLiteral("syncData")) {
-            m_syncData = propertyChange->value().toBool();
+            if (propertyChange->value().toBool())
+                qWarning() << "WARNING: Dragon render aspect does yet not support syncData. Data on frontend node will not be updated.";
             markDirty();
         }
-        //        markDirty(AbstractRenderer::BuffersDirty);
     }
     BackendNode::sceneChangeEvent(e);
 }
 
+bool operator ==(const Buffer &a, const Buffer &b)
+{
+    return compareGenerators(a.m_generator, b.m_generator) && a.m_access == b.m_access && a.m_data == b.m_data
+            && a.m_type == b.m_type && a.m_usage == b.m_usage;
+}
+
 } // Dragon
 } // Qt3DRender
 
diff --git a/src/runtime/dragon/geometry/dragonbuffer_p.h b/src/runtime/dragon/geometry/dragonbuffer_p.h
index 4f121b9..63fde0a 100644
--- a/src/runtime/dragon/geometry/dragonbuffer_p.h
+++ b/src/runtime/dragon/geometry/dragonbuffer_p.h
@@ -60,33 +60,24 @@ namespace Dragon {
 class Buffer : public BackendNode
 {
 public:
+    virtual ~Buffer() = default;
+
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
 
-    QBufferDataGeneratorPtr generator() const;
-
-    bool isAsynchronous() const;
-
-//private:
-
     QBuffer::UsageType m_usage = QBuffer::StreamDraw;
     QByteArray m_data;
-    QVector<Qt3DRender::QBufferUpdate> m_bufferUpdates;
-    bool m_bufferDirty = false;
-    bool m_syncData = false;
     QBuffer::AccessType m_access = QBuffer::Write;
     QBufferDataGeneratorPtr m_generator;
-    bool m_isAsynchronous = false;
     QBuffer::BufferType m_type;
 };
 
+bool operator ==(const Buffer &a, const Buffer &b);
+
 struct LoadedBuffer
 {
-    Qt3DCore::QNodeId peerId;
     QByteArray data;
-    QFuture<QByteArray> future;
-    QBufferDataGeneratorPtr generator;
-    bool isAsynchronous = false;
+    Immutable<Buffer> buffer;
 };
 
 } // namespace Dragon
diff --git a/src/runtime/dragon/jobs/dragonbufferjobs.cpp b/src/runtime/dragon/jobs/dragonbufferjobs.cpp
index e5642fc..0060b6a 100644
--- a/src/runtime/dragon/jobs/dragonbufferjobs.cpp
+++ b/src/runtime/dragon/jobs/dragonbufferjobs.cpp
@@ -51,46 +51,22 @@ LoadedBuffers loadBuffers(LoadedBuffers loadedBuffers, const ValueContainer<Buff
     auto generateBuffer = [](const QNodeId &id, const Immutable<Buffer> &buffer) {
         Q_UNUSED(id);
         LoadedBuffer result;
-        result.peerId = buffer->peerId();
-        if (buffer->generator() == nullptr) {
+        result.buffer = buffer;
+
+        if (buffer->m_generator == nullptr) {
             result.data = buffer->m_data;
             return result;
         }
-        // Note: This does not and should not use the same thread pool as the jobs,
-        // because the pool size could be 1, in which case this job might already
-        // have filled the entire pool and we cannot wait for it to finish
-        result.generator = buffer->generator();
-        result.isAsynchronous = buffer->isAsynchronous();
-        auto generateBufferSync = [](QBufferDataGeneratorPtr generator) { return (*generator)(); };
-        result.future = QtConcurrent::run(generateBufferSync, buffer->generator());
-
-        // TODO remove when async loading is implemented again
-        result.future.waitForFinished();
-        result.data = result.future.result();
-
+        result.data = (*buffer->m_generator)();
         return result;
     };
 
     auto compare = [](const Immutable<LoadedBuffer> &cached, const Immutable<Buffer> &buffer) {
-        return buffer->generator() != nullptr && cached->generator != nullptr
-            && *buffer->generator() == *cached->generator;
+        return cached->buffer == buffer;
     };
 
     loadedBuffers = synchronizeKeys(std::move(loadedBuffers), buffers, compare, generateBuffer);
 
-//    for (auto &loadingBuffer : loadedBuffers) {
-        // TODO should not go through entire list here
-
-//        if (!loadingBuffer->isAsynchronous) {
-//            loadingBuffer->future.waitForFinished();
-//        }
-        // TODO allow for async loading again
-//        if (loadingBuffer->generator != nullptr) {
-//            loadingBuffer->future.waitForFinished();
-//            loadingBuffer->data = loadingBuffer->future.result();
-//        }
-//    }
-
     return loadedBuffers;
 }