Implement WaitFence/SetFence handling into the renderer

Slightly reorganize jobs between jobs needed for rendering and jobs
that should run even when no rendering is required.

Change-Id: I02d262efd8cb46c71c40ac6dbcd4d1b25bb725e1
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

6 files changed, 427 insertions, 21 deletions

diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index 466cebe14..f19b3211b 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -57,6 +57,7 @@ public:
     bool isRunning() const override { return true; }
     bool shouldRender() override { return true; }
     void skipNextFrame() override {}
+    QVector<Qt3DCore::QAspectJobPtr> preRenderingJobs() override { return QVector<Qt3DCore::QAspectJobPtr>(); }
     QVector<Qt3DCore::QAspectJobPtr> renderBinJobs() override { return QVector<Qt3DCore::QAspectJobPtr>(); }
     Qt3DCore::QAspectJobPtr pickBoundingVolumeJob() override { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr rayCastingJob() override { return Qt3DCore::QAspectJobPtr(); }
diff --git a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
index 584b675ee..c34372f70 100644
--- a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
+++ b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
@@ -926,6 +926,9 @@ private Q_SLOTS:
         SUPPORTS_FEATURE(GraphicsHelperInterface::DrawBuffersBlend, false);
         SUPPORTS_FEATURE(GraphicsHelperInterface::Tessellation, false);
         SUPPORTS_FEATURE(GraphicsHelperInterface::BlitFramebuffer, false);
+        SUPPORTS_FEATURE(GraphicsHelperInterface::IndirectDrawing, false);
+        SUPPORTS_FEATURE(GraphicsHelperInterface::MapBuffer, true);
+        SUPPORTS_FEATURE(GraphicsHelperInterface::Fences, false);
     }
 
 
@@ -1524,6 +1527,36 @@ private Q_SLOTS:
         // Not supported by GL2
     }
 
+    void fenceSync()
+    {
+        QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+        // Not supported by GL2
+    }
+
+    void clientWaitSync()
+    {
+        QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+        // Not supported by GL2
+    }
+
+    void waitSync()
+    {
+        QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+        // Not supported by GL2
+    }
+
+    void wasSyncSignaled()
+    {
+        QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+        // Not supported by GL2
+    }
+
+    void deleteSync()
+    {
+        QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+        // Not supported by GL2
+    }
+
 private:
     QScopedPointer<QWindow> m_window;
     QOpenGLContext m_glContext;
diff --git a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
index 648eaaddb..3ef8de6ec 100644
--- a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
+++ b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
@@ -2151,6 +2151,105 @@ private Q_SLOTS:
         QCOMPARE(p, GL_FRONT);
     }
 
+    void fenceSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        // THEN
+        QVERIFY(sync != nullptr);
+        QCOMPARE(m_func->glIsSync(sync), GL_TRUE);
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void clientWaitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        QElapsedTimer t;
+        t.start();
+
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        m_glHelper.clientWaitSync(sync, 1000000);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        qDebug() << t.nsecsElapsed();
+    }
+
+    void waitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void wasSyncSignaled()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+
+        // Shouldn't loop forever
+        while (!m_glHelper.wasSyncSignaled(sync))
+            ;
+    }
+
+    void deleteSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_glHelper.clientWaitSync(sync, GLuint64(-1));
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        QVERIFY(m_glHelper.wasSyncSignaled(sync) == true);
+
+        // WHEN
+        m_glHelper.deleteSync(sync);
+
+        // THEN
+        QCOMPARE(m_func->glIsSync(sync), GL_FALSE);
+    }
+
 private:
     QScopedPointer<QWindow> m_window;
     QOpenGLContext m_glContext;
diff --git a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
index 06a3c41cd..a6a41ffd4 100644
--- a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
+++ b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
@@ -2251,6 +2251,105 @@ private Q_SLOTS:
         QCOMPARE(p, GL_FRONT);
     }
 
+    void fenceSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        // THEN
+        QVERIFY(sync != nullptr);
+        QCOMPARE(m_func->glIsSync(sync), GL_TRUE);
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void clientWaitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        QElapsedTimer t;
+        t.start();
+
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        m_glHelper.clientWaitSync(sync, 1000000);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        qDebug() << t.nsecsElapsed();
+    }
+
+    void waitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void wasSyncSignaled()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+
+        // Shouldn't loop forever
+        while (!m_glHelper.wasSyncSignaled(sync))
+            ;
+    }
+
+    void deleteSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_glHelper.clientWaitSync(sync, GLuint64(-1));
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        QVERIFY(m_glHelper.wasSyncSignaled(sync) == true);
+
+        // WHEN
+        m_glHelper.deleteSync(sync);
+
+        // THEN
+        QCOMPARE(m_func->glIsSync(sync), GL_FALSE);
+    }
+
 private:
     QScopedPointer<QWindow> m_window;
     QOpenGLContext m_glContext;
diff --git a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
index 39bd15021..6632f65de 100644
--- a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
+++ b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
@@ -1430,7 +1430,7 @@ private Q_SLOTS:
 
     void supportsFeature()
     {
-        for (int i = 0; i <= GraphicsHelperInterface::BlitFramebuffer; ++i)
+        for (int i = 0; i <= GraphicsHelperInterface::Fences; ++i)
             QVERIFY(m_glHelper.supportsFeature(static_cast<GraphicsHelperInterface::Feature>(i)));
     }
 
@@ -2349,6 +2349,105 @@ private Q_SLOTS:
         QCOMPARE(p, GL_FRONT);
     }
 
+    void fenceSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        // THEN
+        QVERIFY(sync != nullptr);
+        QCOMPARE(m_func->glIsSync(sync), GL_TRUE);
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void clientWaitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        QElapsedTimer t;
+        t.start();
+
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+
+        m_glHelper.clientWaitSync(sync, 1000000);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        qDebug() << t.nsecsElapsed();
+    }
+
+    void waitSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
+    void wasSyncSignaled()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_func->glFlush();
+        m_glHelper.waitSync(sync);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+
+        // Shouldn't loop forever
+        while (!m_glHelper.wasSyncSignaled(sync))
+            ;
+    }
+
+    void deleteSync()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        m_func->glGetError();
+
+        // WHEN
+        GLsync sync = reinterpret_cast<GLsync>(m_glHelper.fenceSync());
+        m_glHelper.clientWaitSync(sync, GLuint64(-1));
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+        QVERIFY(m_glHelper.wasSyncSignaled(sync) == true);
+
+        // WHEN
+        m_glHelper.deleteSync(sync);
+
+        // THEN
+        QCOMPARE(m_func->glIsSync(sync), GL_FALSE);
+    }
+
 private:
     QScopedPointer<QWindow> m_window;
     QOpenGLContext m_glContext;
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index 9f6007181..bd1f7185e 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -44,6 +44,88 @@ public :
     ~tst_Renderer() {}
 
 private Q_SLOTS:
+
+    void checkPreRenderBinJobs()
+    {
+        // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OffscreenSurfaceHelper offscreenHelper(&renderer);
+        Qt3DRender::Render::RenderSettings settings;
+        // owned by FG manager
+        Qt3DRender::Render::ViewportNode *fgRoot = new Qt3DRender::Render::ViewportNode();
+        const Qt3DCore::QNodeId fgRootId = Qt3DCore::QNodeId::createId();
+
+        nodeManagers.frameGraphManager()->appendNode(fgRootId, fgRoot);
+        settings.setActiveFrameGraphId(fgRootId);
+
+        renderer.setNodeManagers(&nodeManagers);
+        renderer.setSettings(&settings);
+        renderer.setOffscreenSurfaceHelper(&offscreenHelper);
+        renderer.initialize();
+
+        // Ensure invoke calls are performed
+        QCoreApplication::processEvents();
+
+        // WHEN (nothing dirty, no buffers, no layers to be rebuilt, no materials to be rebuilt)
+        QVector<Qt3DCore::QAspectJobPtr> jobs = renderer.preRenderingJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 1 + // PickBoundingVolumeJob
+                 1); // RayCastingJob
+
+        // WHEN
+        renderer.addRenderCaptureSendRequest(Qt3DCore::QNodeId::createId());
+        jobs = renderer.preRenderingJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 1 + // PickBoundingVolumeJob
+                 1 + // RayCastingJob
+                 1); // SendRenderCaptureJob
+
+        // WHEN
+        renderer.m_sendBufferCaptureJob->addRequest({nullptr, {}});
+        jobs = renderer.preRenderingJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 1 + // PickBoundingVolumeJob
+                 1 + // RayCastingJob
+                 1); // SendBufferCaptureJob
+        // Note: pending render buffer captures are only cleared when the job is run
+
+        // WHEN
+        renderer.m_updatedSetFences.push_back({Qt3DCore::QNodeId(), nullptr});
+        jobs = renderer.preRenderingJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 1 + // PickBoundingVolumeJob
+                 1 + // RayCastingJob
+                 1 + // SendBufferCaptureJob
+                 1); // SendSetFenceHandlesJob
+        // Note: pending set fence handles are only cleared when the job is run
+
+        // WHEN
+        renderer.m_updatedTextureProperties.push_back({{}, {}});
+        jobs = renderer.preRenderingJobs();
+
+        // THEN
+        QCOMPARE(jobs.size(),
+                 1 + // PickBoundingVolumeJob
+                 1 + // RayCastingJob
+                 1 + // SendBufferCaptureJob
+                 1 + // SendSetFenceHandlesJob
+                 1); // SendTextureChangesToFrontend
+
+        // Note: pending texture changes are only cleared when the job is run
+
+        // Properly shutdown command thread
+        renderer.shutdown();
+    }
+
     void checkRenderBinJobs()
     {
         // GIVEN
@@ -90,7 +172,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  singleRenderViewJobCount); // Only valid for the first call to renderBinJobs(), since subsequent calls won't have the renderqueue reset
@@ -98,19 +179,6 @@ private Q_SLOTS:
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         // WHEN
-        renderer.addRenderCaptureSendRequest(Qt3DCore::QNodeId::createId());
-        jobs = renderer.renderBinJobs();
-
-        // THEN
-        QCOMPARE(jobs.size(),
-                 1 + // updateLevelOfDetailJob
-                 1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
-                 1 + // sendRenderCaptureJob
-                 1 + // VAOGatherer
-                 1); // updateSkinningPaletteJob
-
-        // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityEnabledDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
@@ -118,7 +186,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  1); // EntityEnabledDirty
@@ -133,7 +200,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
@@ -151,7 +217,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // CalculateBoundingVolumeJob
                  1 + // UpdateMeshTriangleListJob
@@ -168,7 +233,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // updateSkinningPaletteJob
                  1); // BufferGathererJob
@@ -183,7 +247,6 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // TexturesGathererJob
                  1 + // updateSkinningPaletteJob
@@ -191,6 +254,19 @@ private Q_SLOTS:
 
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
+
+        // WHEN
+        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::FrameGraphDirty, nullptr);
+        jobs = renderer.renderBinJobs();
+
+        QCOMPARE(jobs.size(),
+                 1 + // updateLevelOfDetailJob
+                 1 + // cleanupJob
+                 1 + // VAOGatherer
+                 1); // updateSkinningPaletteJob
+
+        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+
         // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
         jobs = renderer.renderBinJobs();
@@ -208,7 +284,6 @@ private Q_SLOTS:
                  1 + // updateSkinningPaletteJob
                  1 + // updateLevelOfDetailJob
                  1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
                  1 + // VAOGatherer
                  1 + // BufferGathererJob
                  1 + // TexturesGathererJob