Change renderOnce to RenderPolicy enum

Change-Id: Ie37085ec884034c0f080c782ec44505f046c50bd
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

7 files changed, 43 insertions, 35 deletions

diff --git a/src/quick3d/quick3drender/scene2d/qscene2d.cpp b/src/quick3d/quick3drender/scene2d/qscene2d.cpp
index f83cd3e4f..fa46cd3d2 100644
--- a/src/quick3d/quick3drender/scene2d/qscene2d.cpp
+++ b/src/quick3d/quick3drender/scene2d/qscene2d.cpp
@@ -72,10 +72,18 @@ namespace Quick {
     \ingroup
     \instantiates Qt3DRender::QScene2D
     \brief Scene2D
- *
  */
 
 /*!
+    \enum QScene2D::RenderPolicy
+
+    This enum type describes types of render policies available.
+    \value Continuous The Scene2D is rendering continuously. This is the default render policy.
+    \value SingleShot The Scene2D renders to the texture only once after which the resources
+                      allocated for rendering are released.
+*/
+
+/*!
     \qmlproperty RenderTargetOutput Qt3D.Render::Scene2D::output
     Holds the RenderTargetOutput, which specifies where the Scene2D is rendering to.
  */
@@ -86,10 +94,8 @@ namespace Quick {
  */
 
 /*!
-    \qmlproperty bool Qt3D.Render::Scene2D::renderOnce
-    Holds whether the first rendered image to the texture is also the last, after which the
-    renderer releases resources needed for the rendering and the rendering is no longer possible
-    with this Scene2D object.
+    \qmlproperty enumeration Qt3D.Render::Scene2D::renderPolicy
+    Holds the render policy of this Scene2D.
  */
 
 /*!
@@ -232,7 +238,7 @@ Scene2DManager::Scene2DManager(QScene2DPrivate *priv)
     , m_initialized(false)
     , m_renderSyncRequested(false)
     , m_sharedObject(new Scene2DSharedObject(this))
-    , m_renderOnce(false)
+    , m_renderPolicy(QScene2D::Continuous)
     , m_backendInitialized(false)
     , m_noSourceMode(false)
     , m_item(nullptr)
@@ -607,26 +613,22 @@ void QScene2D::setItem(QQuickItem *item)
 }
 
 /*!
-    \property QScene2D::renderOnce
-    \brief Property to specify if the texture will be rendered only once.
+    \property QScene2D::renderPolicy
 
-    This property specifies that the texture will be rendered only one time.
-    Once the rendering has been done, resources reserved for rendering will be
-    released and the QScene2D will become unusable.
-    If set to false, which is the default, the rendering is continuous.
+    Holds the render policy of this Scene2D.
  */
-bool QScene2D::renderOnce() const
+QScene2D::RenderPolicy QScene2D::renderPolicy() const
 {
     Q_D(const QScene2D);
-    return d->m_renderManager->m_renderOnce;
+    return d->m_renderManager->m_renderPolicy;
 }
 
-void QScene2D::setRenderOnce(bool once)
+void QScene2D::setRenderPolicy(QScene2D::RenderPolicy renderPolicy)
 {
     Q_D(const QScene2D);
-    if (d->m_renderManager->m_renderOnce != once) {
-        d->m_renderManager->m_renderOnce = once;
-        emit renderOnceChanged(once);
+    if (d->m_renderManager->m_renderPolicy != renderPolicy) {
+        d->m_renderManager->m_renderPolicy = renderPolicy;
+        emit renderPolicyChanged(renderPolicy);
     }
 }
 
@@ -659,7 +661,7 @@ Qt3DCore::QNodeCreatedChangeBasePtr QScene2D::createNodeCreationChange() const
     auto creationChange = Qt3DCore::QNodeCreatedChangePtr<QScene2DData>::create(this);
     auto &data = creationChange->data;
     Q_D(const QScene2D);
-    data.renderOnce = d->m_renderManager->m_renderOnce;
+    data.renderPolicy = d->m_renderManager->m_renderPolicy;
     data.sharedObject = d->m_renderManager->m_sharedObject;
     data.output = d->m_output ? d->m_output->id() : Qt3DCore::QNodeId();
     return creationChange;
diff --git a/src/quick3d/quick3drender/scene2d/qscene2d.h b/src/quick3d/quick3drender/scene2d/qscene2d.h
index 77ad6ea86..0a7e943d6 100644
--- a/src/quick3d/quick3drender/scene2d/qscene2d.h
+++ b/src/quick3d/quick3drender/scene2d/qscene2d.h
@@ -61,13 +61,20 @@ class QT3DQUICKRENDERSHARED_EXPORT QScene2D : public Qt3DCore::QNode
 
     Q_PROPERTY(Qt3DRender::QRenderTargetOutput *output READ output WRITE setOutput NOTIFY outputChanged)
     Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
-    Q_PROPERTY(bool renderOnce READ renderOnce WRITE setRenderOnce NOTIFY renderOnceChanged)
+    Q_PROPERTY(QScene2D::RenderPolicy renderPolicy READ renderPolicy WRITE setRenderPolicy NOTIFY renderPolicyChanged)
     Q_PROPERTY(bool loaded READ loaded NOTIFY loadedChanged)
     Q_PROPERTY(QQuickItem *item READ item WRITE setItem NOTIFY itemChanged)
 
     Q_CLASSINFO("DefaultProperty", "item")
 
 public:
+
+    enum RenderPolicy {
+        Continuous,
+        SingleShot
+    };
+    Q_ENUM(RenderPolicy)
+
     explicit QScene2D(Qt3DCore::QNode *parent = nullptr);
     QScene2D(QQmlEngine *engine, Qt3DCore::QNode *parent = nullptr);
     ~QScene2D();
@@ -75,7 +82,7 @@ public:
     Qt3DRender::QRenderTargetOutput *output() const;
     QUrl source() const;
     bool loaded() const;
-    bool renderOnce() const;
+    QScene2D::RenderPolicy renderPolicy() const;
     QQuickItem *item() const;
     QQmlEngine *engine() const;
     bool event(QEvent *event) Q_DECL_OVERRIDE;
@@ -83,14 +90,14 @@ public:
 public Q_SLOTS:
     void setOutput(Qt3DRender::QRenderTargetOutput *output);
     void setSource(const QUrl &url);
-    void setRenderOnce(bool once);
+    void setRenderPolicy(QScene2D::RenderPolicy policy);
     void setItem(QQuickItem *item);
 
 Q_SIGNALS:
     void outputChanged(Qt3DRender::QRenderTargetOutput *output);
     void sourceChanged(const QUrl &url);
     void loadedChanged(bool loaded);
-    void renderOnceChanged(bool once);
+    void renderPolicyChanged(QScene2D::RenderPolicy policy);
     void itemChanged(QQuickItem *item);
 
 protected:
diff --git a/src/quick3d/quick3drender/scene2d/qscene2d_p.h b/src/quick3d/quick3drender/scene2d/qscene2d_p.h
index 95f32f7c9..34b54b231 100644
--- a/src/quick3d/quick3drender/scene2d/qscene2d_p.h
+++ b/src/quick3d/quick3drender/scene2d/qscene2d_p.h
@@ -156,7 +156,7 @@ public:
 
 struct QScene2DData
 {
-    bool renderOnce;
+    QScene2D::RenderPolicy renderPolicy;
     Scene2DSharedObjectPtr sharedObject;
     Qt3DCore::QNodeId output;
 };
@@ -179,11 +179,11 @@ public:
     QUrl m_source;
     Qt3DCore::QNodeId m_id;
     QMetaObject::Connection m_connection;
+    QScene2D::RenderPolicy m_renderPolicy;
 
     bool m_requested;
     bool m_initialized;
     bool m_renderSyncRequested;
-    bool m_renderOnce;
     bool m_backendInitialized;
     bool m_noSourceMode;
     bool m_ownEngine;
diff --git a/src/quick3d/quick3drender/scene2d/scene2d.cpp b/src/quick3d/quick3drender/scene2d/scene2d.cpp
index 35c791000..227829f3e 100644
--- a/src/quick3d/quick3drender/scene2d/scene2d.cpp
+++ b/src/quick3d/quick3drender/scene2d/scene2d.cpp
@@ -109,7 +109,7 @@ Scene2D::Scene2D()
     , m_renderThread(nullptr)
     , m_initialized(false)
     , m_renderInitialized(false)
-    , m_renderOnce(false)
+    , m_renderPolicy(Qt3DRender::Quick::QScene2D::Continuous)
     , m_fbo(0)
     , m_rbo(0)
 {
@@ -160,7 +160,7 @@ void Scene2D::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chan
 {
     const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QScene2DData>>(change);
     const auto &data = typedChange->data;
-    m_renderOnce = data.renderOnce;
+    m_renderPolicy = data.renderPolicy;
     setSharedObject(data.sharedObject);
     setOutput(data.output);
     m_shareContext = renderer()->shareContext();
@@ -171,9 +171,9 @@ void Scene2D::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     if (e->type() == Qt3DCore::PropertyUpdated) {
         Qt3DCore::QPropertyUpdatedChangePtr propertyChange
                 = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("renderOnce"))
-            m_renderOnce = propertyChange->value().toBool();
-        else if (propertyChange->propertyName() == QByteArrayLiteral("output")) {
+        if (propertyChange->propertyName() == QByteArrayLiteral("renderPolicy")) {
+            m_renderPolicy = propertyChange->value().value<QScene2D::RenderPolicy>();
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("output")) {
             Qt3DCore::QNodeId outputId = propertyChange->value().value<Qt3DCore::QNodeId>();
             setOutput(outputId);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("sharedObject")) {
@@ -299,7 +299,7 @@ void Scene2D::render()
             m_sharedObject->m_quickWindow->setRenderTarget(m_fbo, m_textureSize);
 
         // Call disallow rendering while mutex is locked
-        if (m_renderOnce)
+        if (m_renderPolicy == QScene2D::SingleShot)
             m_sharedObject->disallowRender();
 
         // Sync
@@ -314,7 +314,7 @@ void Scene2D::render()
         m_sharedObject->m_renderControl->render();
 
         // Tell main thread we are done so it can begin cleanup if this is final frame
-        if (m_renderOnce)
+        if (m_renderPolicy == QScene2D::SingleShot)
             QCoreApplication::postEvent(m_sharedObject->m_renderManager, new QEvent(RENDERED));
 
         m_sharedObject->m_quickWindow->resetOpenGLState();
diff --git a/src/quick3d/quick3drender/scene2d/scene2d_p.h b/src/quick3d/quick3drender/scene2d/scene2d_p.h
index fdb4ff1d2..3a8ccf531 100644
--- a/src/quick3d/quick3drender/scene2d/scene2d_p.h
+++ b/src/quick3d/quick3drender/scene2d/scene2d_p.h
@@ -49,6 +49,7 @@
 //
 
 #include <Qt3DCore/qnodeid.h>
+#include <Qt3DQuickRender/qscene2d.h>
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QSemaphore>
@@ -114,7 +115,7 @@ public:
 
     bool m_initialized;
     bool m_renderInitialized;
-    bool m_renderOnce;
+    Qt3DRender::Quick::QScene2D::RenderPolicy m_renderPolicy;
 };
 
 } // Quick
diff --git a/tests/manual/render-qml-to-texture-qml/main.qml b/tests/manual/render-qml-to-texture-qml/main.qml
index 23ff823e1..32c919af7 100644
--- a/tests/manual/render-qml-to-texture-qml/main.qml
+++ b/tests/manual/render-qml-to-texture-qml/main.qml
@@ -71,7 +71,6 @@ QQ2.Item {
 
             Scene2D {
                 id: qmlTexture
-                renderOnce: false
                 output: RenderTargetOutput {
                     attachmentPoint: RenderTargetOutput.Color0
                     texture: Texture2D {
diff --git a/tests/manual/render-qml-to-texture/main.cpp b/tests/manual/render-qml-to-texture/main.cpp
index 609da2ebe..79c0dbca2 100644
--- a/tests/manual/render-qml-to-texture/main.cpp
+++ b/tests/manual/render-qml-to-texture/main.cpp
@@ -103,7 +103,6 @@ int main(int argc, char *argv[])
 
     qmlTextureRenderer->setOutput(output);
     qmlTextureRenderer->setSource(QUrl(QStringLiteral("qrc:/OffscreenGui.qml")));
-//    qmlTextureRenderer->setRenderOnce(true);
 
     Qt3DCore::QEntity* planeEntity = new Qt3DCore::QEntity(sceneRoot);
     Qt3DExtras::QPlaneMesh* planeMesh = new Qt3DExtras::QPlaneMesh(planeEntity);