RenderQueue: switch to std::vector

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

15 files changed, 133 insertions, 199 deletions

diff --git a/src/plugins/renderers/opengl/debug/imguirenderer.cpp b/src/plugins/renderers/opengl/debug/imguirenderer.cpp
index eb679f36c..5ee72985a 100644
--- a/src/plugins/renderers/opengl/debug/imguirenderer.cpp
+++ b/src/plugins/renderers/opengl/debug/imguirenderer.cpp
@@ -165,7 +165,7 @@ ImGuiRenderer::ImGuiRenderer(Qt3DRender::Render::OpenGL::Renderer *renderer)
 
 ImGuiRenderer::~ImGuiRenderer() = default;
 
-void ImGuiRenderer::renderDebugOverlay(const QVector<RenderView *> &renderViews, const RenderView *renderView, int jobsInLastFrame)
+void ImGuiRenderer::renderDebugOverlay(const std::vector<RenderView *> &renderViews, const RenderView *renderView, int jobsInLastFrame)
 {
     if (!newFrame(renderView))
         return;
@@ -323,7 +323,7 @@ void ImGuiRenderer::showGLInfo()
     ImGui::End();
 }
 
-void ImGuiRenderer::showRenderDetails(const QVector<RenderView *> &renderViews)
+void ImGuiRenderer::showRenderDetails(const std::vector<RenderView *> &renderViews)
 {
     ImGui::Begin("Render Views", &m_showRenderDetailsWindow);
 
diff --git a/src/plugins/renderers/opengl/debug/imguirenderer_p.h b/src/plugins/renderers/opengl/debug/imguirenderer_p.h
index b4b43dc72..d70bd3259 100644
--- a/src/plugins/renderers/opengl/debug/imguirenderer_p.h
+++ b/src/plugins/renderers/opengl/debug/imguirenderer_p.h
@@ -87,7 +87,7 @@ public:
     ~ImGuiRenderer();
 
     void processEvent(QEvent *event);
-    void renderDebugOverlay(const QVector<Render::OpenGL::RenderView *> &renderViews, const Render::OpenGL::RenderView *renderView, int jobsInLastFrame);
+    void renderDebugOverlay(const std::vector<Render::OpenGL::RenderView *> &renderViews, const Render::OpenGL::RenderView *renderView, int jobsInLastFrame);
 
     void setCapabilities(const QString &capabilities);
 
@@ -98,7 +98,7 @@ private:
     void onWheel(QWheelEvent *event);
     void onKeyPressRelease(QKeyEvent *event);
     void showGLInfo();
-    void showRenderDetails(const QVector<Render::OpenGL::RenderView *> &renderViews);
+    void showRenderDetails(const std::vector<Render::OpenGL::RenderView *> &renderViews);
 
     bool createFontsTexture();
     bool createDeviceObjects();
diff --git a/src/plugins/renderers/opengl/renderer/commandexecuter.cpp b/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
index c99f69fd3..ebb008df7 100644
--- a/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
+++ b/src/plugins/renderers/opengl/renderer/commandexecuter.cpp
@@ -232,7 +232,7 @@ CommandExecuter::CommandExecuter(Render::OpenGL::Renderer *renderer)
 }
 
 // Render thread
-void CommandExecuter::performAsynchronousCommandExecution(const QVector<Render::OpenGL::RenderView *> &views)
+void CommandExecuter::performAsynchronousCommandExecution(const std::vector<Render::OpenGL::RenderView *> &views)
 {
     QMutexLocker lock(&m_pendingCommandsMutex);
     const QVector<Qt3DCore::Debug::AsynchronousCommandReply *> shellCommands = std::move(m_pendingCommands);
diff --git a/src/plugins/renderers/opengl/renderer/commandexecuter_p.h b/src/plugins/renderers/opengl/renderer/commandexecuter_p.h
index 9aea9fc2f..e87aafa14 100644
--- a/src/plugins/renderers/opengl/renderer/commandexecuter_p.h
+++ b/src/plugins/renderers/opengl/renderer/commandexecuter_p.h
@@ -78,7 +78,7 @@ class CommandExecuter
 public:
     explicit CommandExecuter(Render::OpenGL::Renderer *renderer);
 
-    void performAsynchronousCommandExecution(const QVector<Render::OpenGL::RenderView *> &views);
+    void performAsynchronousCommandExecution(const std::vector<Render::OpenGL::RenderView *> &views);
 
     QVariant executeCommand(const QStringList &args);
 
diff --git a/src/plugins/renderers/opengl/renderer/renderer.cpp b/src/plugins/renderers/opengl/renderer/renderer.cpp
index 4f77f19d0..6ceafb944 100644
--- a/src/plugins/renderers/opengl/renderer/renderer.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderer.cpp
@@ -678,135 +678,85 @@ RenderSettings *Renderer::settings() const
     return m_settings;
 }
 
-void Renderer::render()
-{
-    // Traversing the framegraph tree from root to lead node
-    // Allows us to define the rendering set up
-    // Camera, RenderTarget ...
-
-    // Utimately the renderer should be a framework
-    // For the processing of the list of renderviews
-
-    // Matrice update, bounding volumes computation ...
-    // Should be jobs
-
-    // namespace Qt3DCore has 2 distincts node trees
-    // One scene description
-    // One framegraph description
-
-    while (m_running.loadRelaxed() > 0) {
-        doRender();
-        // TO DO: Restore windows exposed detection
-        // Probably needs to happens some place else though
-    }
-}
-
 // Either called by render if Qt3D is in charge of rendering (in the mainthread)
-// or by QRenderAspectPrivate::renderSynchronous (for Scene3D, potentially from a RenderThread)
-void Renderer::doRender(bool swapBuffers)
+// or by QRenderAspectPrivate::render (for Scene3D, potentially from a RenderThread)
+// This will wait until renderQueue is ready or shutdown was requested
+void Renderer::render(bool swapBuffers)
 {
     Renderer::ViewSubmissionResultData submissionData;
-    bool hasCleanedQueueAndProceeded = false;
     bool preprocessingComplete = false;
     bool beganDrawing = false;
 
     // Blocking until RenderQueue is full
     const bool canSubmit = waitUntilReadyToSubmit();
-    m_shouldSwapBuffers = swapBuffers;
 
-    // Lock the mutex to protect access to the renderQueue while we look for its state
-    QMutexLocker locker(m_renderQueue->mutex());
-    const bool queueIsComplete = m_renderQueue->isFrameQueueComplete();
-    const bool queueIsEmpty = m_renderQueue->targetRenderViewCount() == 0;
+    // If it returns false -> we are shutting down
+    if (!canSubmit)
+        return;
 
-    // When using synchronous rendering (QtQuick)
-    // We are not sure that the frame queue is actually complete
-    // Since a call to render may not be synched with the completions
-    // of the RenderViewJobs
-    // In such a case we return early, waiting for a next call with
-    // the frame queue complete at this point
+    m_shouldSwapBuffers = swapBuffers;
+    const std::vector<Render::OpenGL::RenderView *> &renderViews = m_renderQueue->nextFrameQueue();
+    const bool queueIsEmpty = m_renderQueue->targetRenderViewCount() == 0;
 
     // RenderQueue is complete (but that means it may be of size 0)
-    if (canSubmit && (queueIsComplete && !queueIsEmpty)) {
-        const QVector<Render::OpenGL::RenderView *> renderViews = m_renderQueue->nextFrameQueue();
+    if (!queueIsEmpty) {
         QTaskLogger submissionStatsPart1(m_services->systemInformation(),
                                          {JobTypes::FrameSubmissionPart1, 0},
                                          QTaskLogger::Submission);
         QTaskLogger submissionStatsPart2(m_services->systemInformation(),
                                          {JobTypes::FrameSubmissionPart2, 0},
                                          QTaskLogger::Submission);
-        if (canRender()) {
-            { // Scoped to destroy surfaceLock
-                QSurface *surface = nullptr;
-                for (const RenderView *rv: renderViews) {
-                    surface = rv->surface();
-                    if (surface)
-                        break;
-                }
+        { // Scoped to destroy surfaceLock
+            QSurface *surface = nullptr;
+            for (const RenderView *rv: renderViews) {
+                surface = rv->surface();
+                if (surface)
+                    break;
+            }
 
-                SurfaceLocker surfaceLock(surface);
-                const bool surfaceIsValid = (surface && surfaceLock.isSurfaceValid());
-                if (surfaceIsValid) {
-                    // Reset state for each draw if we don't have complete control of the context
-                    if (!m_ownedContext)
-                        m_submissionContext->setCurrentStateSet(nullptr);
-                    beganDrawing = m_submissionContext->beginDrawing(surface);
-                    if (beganDrawing) {
-                        // 1) Execute commands for buffer uploads, texture updates, shader loading first
-                        updateGLResources();
-                        // 2) Update VAO and copy data into commands to allow concurrent submission
-                        prepareCommandsSubmission(renderViews);
-                        preprocessingComplete = true;
-
-                        // Purge shader which aren't used any longer
-                        static int callCount = 0;
-                        ++callCount;
-                        const int shaderPurgePeriod = 600;
-                        if (callCount % shaderPurgePeriod == 0)
-                            m_glResourceManagers->glShaderManager()->purge();
-                    }
+            SurfaceLocker surfaceLock(surface);
+            const bool surfaceIsValid = (surface && surfaceLock.isSurfaceValid());
+            if (surfaceIsValid) {
+                // Reset state for each draw if we don't have complete control of the context
+                if (!m_ownedContext)
+                    m_submissionContext->setCurrentStateSet(nullptr);
+                beganDrawing = m_submissionContext->beginDrawing(surface);
+                if (beganDrawing) {
+                    // 1) Execute commands for buffer uploads, texture updates, shader loading first
+                    updateGLResources();
+                    // 2) Update VAO and copy data into commands to allow concurrent submission
+                    prepareCommandsSubmission(renderViews);
+                    preprocessingComplete = true;
+
+                    // Purge shader which aren't used any longer
+                    static int callCount = 0;
+                    ++callCount;
+                    const int shaderPurgePeriod = 600;
+                    if (callCount % shaderPurgePeriod == 0)
+                        m_glResourceManagers->glShaderManager()->purge();
                 }
             }
+        }
 
-            m_renderQueue->reset();
-            hasCleanedQueueAndProceeded = true;
-
-            // Only try to submit the RenderViews if the preprocessing was successful
-            // This part of the submission is happening in parallel to the RV building for the next frame
-            if (preprocessingComplete) {
-                submissionStatsPart1.end(submissionStatsPart2.restart());
+        // Only try to submit the RenderViews if the preprocessing was successful
+        if (preprocessingComplete) {
+            submissionStatsPart1.end(submissionStatsPart2.restart());
 
-                // 3) Submit the render commands for frame n (making sure we never reference something that could be changing)
-                // Render using current device state and renderer configuration
-                submissionData = submitRenderViews(renderViews);
+            // 3) Submit the render commands for frame n (making sure we never reference something that could be changing)
+            // Render using current device state and renderer configuration
+            submissionData = submitRenderViews(renderViews);
 
-                // Perform any required cleanup of the Graphics resources (Buffers deleted, Shader deleted...)
-                cleanGraphicsResources();
-            }
+            // Perform any required cleanup of the Graphics resources (Buffers deleted, Shader deleted...)
+            cleanGraphicsResources();
         }
 
         // Execute the pending shell commands
         m_commandExecuter->performAsynchronousCommandExecution(renderViews);
 
-        // Delete all the RenderViews which will clear the allocators
-        // that were used for their allocation
-        qDeleteAll(renderViews);
-
         if (preprocessingComplete && activeProfiler())
             m_frameProfiler->writeResults();
     }
 
-    // If hasCleanedQueueAndProceeded isn't true this implies that something went wrong
-    // with the rendering and/or the renderqueue is incomplete from some reason
-    // or alternatively it could be complete but empty (RenderQueue of size 0)
-
-    if (!hasCleanedQueueAndProceeded) {
-        // Reset the m_renderQueue so that we won't try to render
-        // with a queue used by a previous frame with corrupted content
-        // if the current queue was correctly submitted
-        m_renderQueue->reset();
-    }
-
     // Perform the last swapBuffers calls
     // Finish up with last surface used in the list of RenderViews
     if (beganDrawing) {
@@ -818,6 +768,10 @@ void Renderer::doRender(bool swapBuffers)
         m_submissionContext->endDrawing(swapBuffers);
     }
 
+    // Reset RenderQueue and destroy the renderViews
+    m_renderQueue->reset();
+    qDeleteAll(renderViews);
+
     // Allow next frame to be built once we are done doing all rendering
     m_vsyncFrameAdvanceService->proceedToNextFrame();
 }
@@ -843,14 +797,6 @@ void Renderer::enqueueRenderView(RenderView *renderView, int submitOrder)
     }
 }
 
-bool Renderer::canRender() const
-{
-    // TO DO: Check if all surfaces have been destroyed...
-    // It may be better if the last window to be closed trigger a call to shutdown
-    // Rather than having checks for the surface everywhere
-    return true;
-}
-
 Profiling::FrameProfiler *Renderer::activeProfiler() const
 {
     if (m_services && m_services->systemInformation()->isGraphicsTraceEnabled()) {
@@ -903,7 +849,7 @@ QSurfaceFormat Renderer::format()
 }
 
 // When this function is called, we must not be processing the commands for frame n+1
-void Renderer::prepareCommandsSubmission(const QVector<RenderView *> &renderViews)
+void Renderer::prepareCommandsSubmission(const std::vector<RenderView *> &renderViews)
 {
     OpenGLVertexArrayObject *vao = nullptr;
     QHash<HVao, bool> updatedTable;
@@ -1472,13 +1418,13 @@ void Renderer::downloadGLBuffers()
 
 // Happens in RenderThread context when all RenderViewJobs are done
 // Returns the id of the last bound FBO
-Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<RenderView *> &renderViews)
+Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const std::vector<RenderView *> &renderViews)
 {
     QElapsedTimer timer;
     quint64 queueElapsed = 0;
     timer.start();
 
-    const int renderViewsCount = renderViews.size();
+    const size_t renderViewsCount = renderViews.size();
     quint64 frameElapsed = queueElapsed;
     m_lastFrameCorrect.storeRelaxed(1);    // everything fine until now.....
 
@@ -1496,7 +1442,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
     QSurface *lastUsedSurface = nullptr;
 
     bool imGuiOverlayShown = false;
-    for (int i = 0; i < renderViewsCount; ++i) {
+    for (size_t i = 0; i < renderViewsCount; ++i) {
         // Initialize GraphicsContext for drawing
         // If the RenderView has a RenderStateSet defined
         RenderView *renderView = renderViews.at(i);
@@ -1877,78 +1823,72 @@ std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     if (lightsDirty)
         renderBinJobs.push_back(m_lightGathererJob);
 
-    QMutexLocker lock(m_renderQueue->mutex());
-    if (m_renderQueue->wasReset()) { // Have we rendered yet? (Scene3D case)
-        // Traverse the current framegraph. For each leaf node create a
-        // RenderView and set its configuration then create a job to
-        // populate the RenderView with a set of RenderCommands that get
-        // their details from the RenderNodes that are visible to the
-        // Camera selected by the framegraph configuration
-        if (frameGraphDirty) {
-            FrameGraphVisitor visitor(m_nodesManager->frameGraphManager());
-            m_frameGraphLeaves = visitor.traverse(frameGraphRoot());
-            // Remove leaf nodes that no longer exist from cache
-            const QList<FrameGraphNode *> keys = m_cache.leafNodeCache.keys();
-            for (FrameGraphNode *leafNode : keys) {
-                if (std::find(m_frameGraphLeaves.begin(),
-                              m_frameGraphLeaves.end(),
-                              leafNode) == m_frameGraphLeaves.end())
-                    m_cache.leafNodeCache.remove(leafNode);
-            }
-
-            // Handle single shot subtree enablers
-            const auto subtreeEnablers = visitor.takeEnablersToDisable();
-            for (auto *node : subtreeEnablers)
-                m_updatedDisableSubtreeEnablers.push_back(node->peerId());
+    // Sync rendering is synchronous, queue should always be reset
+    // when this is called
+    Q_ASSERT(m_renderQueue->wasReset());
+    // Traverse the current framegraph. For each leaf node create a
+    // RenderView and set its configuration then create a job to
+    // populate the RenderView with a set of RenderCommands that get
+    // their details from the RenderNodes that are visible to the
+    // Camera selected by the framegraph configuration
+    if (frameGraphDirty) {
+        FrameGraphVisitor visitor(m_nodesManager->frameGraphManager());
+        m_frameGraphLeaves = visitor.traverse(frameGraphRoot());
+        // Remove leaf nodes that no longer exist from cache
+        const QList<FrameGraphNode *> keys = m_cache.leafNodeCache.keys();
+        for (FrameGraphNode *leafNode : keys) {
+            if (std::find(m_frameGraphLeaves.begin(),
+                          m_frameGraphLeaves.end(),
+                          leafNode) == m_frameGraphLeaves.end())
+                m_cache.leafNodeCache.remove(leafNode);
         }
 
-        int idealThreadCount = QThreadPooler::maxThreadCount();
+        // Handle single shot subtree enablers
+        const auto subtreeEnablers = visitor.takeEnablersToDisable();
+        for (auto *node : subtreeEnablers)
+            m_updatedDisableSubtreeEnablers.push_back(node->peerId());
+    }
 
-        const size_t fgBranchCount = m_frameGraphLeaves.size();
-        if (fgBranchCount > 1) {
-            int workBranches = fgBranchCount;
-            for (auto leaf: m_frameGraphLeaves)
-                if (leaf->nodeType() == FrameGraphNode::NoDraw)
-                    --workBranches;
+    int idealThreadCount = QThreadPooler::maxThreadCount();
 
-            if (idealThreadCount > 4 && workBranches)
-                idealThreadCount = qMax(4, idealThreadCount / workBranches);
-        }
+    const size_t fgBranchCount = m_frameGraphLeaves.size();
+    if (fgBranchCount > 1) {
+        int workBranches = fgBranchCount;
+        for (auto leaf: m_frameGraphLeaves)
+            if (leaf->nodeType() == FrameGraphNode::NoDraw)
+                --workBranches;
 
-        for (size_t i = 0; i < fgBranchCount; ++i) {
-            FrameGraphNode *leaf = m_frameGraphLeaves[i];
-            RenderViewBuilder builder(leaf, i, this);
-            builder.setOptimalJobCount(leaf->nodeType() == FrameGraphNode::NoDraw ? 1 : idealThreadCount);
-
-            // If we have a new RV (wasn't in the cache before, then it contains no cached data)
-            const bool isNewRV = !m_cache.leafNodeCache.contains(leaf);
-            builder.setLayerCacheNeedsToBeRebuilt(layersCacheNeedsToBeRebuilt || isNewRV);
-            builder.setMaterialGathererCacheNeedsToBeRebuilt(materialCacheNeedsToBeRebuilt || isNewRV);
-            builder.setRenderCommandCacheNeedsToBeRebuilt(renderCommandsDirty || isNewRV);
-            builder.setLightCacheNeedsToBeRebuilt(lightsDirty);
-
-            // Insert leaf into cache
-            if (isNewRV) {
-                m_cache.leafNodeCache[leaf] = {};
-            }
+        if (idealThreadCount > 4 && workBranches)
+            idealThreadCount = qMax(4, idealThreadCount / workBranches);
+    }
 
-            builder.prepareJobs();
-            const std::vector<QAspectJobPtr> builderJobs = builder.buildJobHierachy();
-            renderBinJobs.insert(renderBinJobs.end(),
-                                 std::make_move_iterator(builderJobs.begin()),
-                                 std::make_move_iterator(builderJobs.end()));
+    for (size_t i = 0; i < fgBranchCount; ++i) {
+        FrameGraphNode *leaf = m_frameGraphLeaves[i];
+        RenderViewBuilder builder(leaf, i, this);
+        builder.setOptimalJobCount(leaf->nodeType() == FrameGraphNode::NoDraw ? 1 : idealThreadCount);
+
+        // If we have a new RV (wasn't in the cache before, then it contains no cached data)
+        const bool isNewRV = !m_cache.leafNodeCache.contains(leaf);
+        builder.setLayerCacheNeedsToBeRebuilt(layersCacheNeedsToBeRebuilt || isNewRV);
+        builder.setMaterialGathererCacheNeedsToBeRebuilt(materialCacheNeedsToBeRebuilt || isNewRV);
+        builder.setRenderCommandCacheNeedsToBeRebuilt(renderCommandsDirty || isNewRV);
+        builder.setLightCacheNeedsToBeRebuilt(lightsDirty);
+
+        // Insert leaf into cache
+        if (isNewRV) {
+            m_cache.leafNodeCache[leaf] = {};
         }
 
-        // Set target number of RenderViews
-        m_renderQueue->setTargetRenderViewCount(fgBranchCount);
-    } else {
-        // FilterLayerEntityJob is part of the RenderViewBuilder jobs and must be run later
-        // if none of those jobs are started this frame
-        notCleared |= AbstractRenderer::EntityEnabledDirty;
-        notCleared |= AbstractRenderer::LayersDirty;
-        notCleared |= AbstractRenderer::FrameGraphDirty;
+        builder.prepareJobs();
+        const std::vector<QAspectJobPtr> builderJobs = builder.buildJobHierachy();
+        renderBinJobs.insert(renderBinJobs.end(),
+                             std::make_move_iterator(builderJobs.begin()),
+                             std::make_move_iterator(builderJobs.end()));
     }
 
+    // Set target number of RenderViews
+    m_renderQueue->setTargetRenderViewCount(fgBranchCount);
+
     if (isRunning() && m_submissionContext->isInitialized()) {
         if (dirtyBitsForFrame & AbstractRenderer::TechniquesDirty )
             renderBinJobs.push_back(m_filterCompatibleTechniqueJob);
diff --git a/src/plugins/renderers/opengl/renderer/renderer_p.h b/src/plugins/renderers/opengl/renderer/renderer_p.h
index 730ea6da3..e86b573e4 100644
--- a/src/plugins/renderers/opengl/renderer/renderer_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderer_p.h
@@ -189,8 +189,7 @@ public:
     void shutdown() override;
     void releaseGraphicsResources() override;
 
-    void render() override;
-    void doRender(bool swapBuffers = true) override;
+    void render(bool swapBuffers = true) override;
     void cleanGraphicsResources() override;
 
     bool isRunning() const override { return m_running.loadRelaxed(); }
@@ -249,7 +248,7 @@ public:
                          QRect outputRect,
                          GLuint defaultFramebuffer);
 
-    void prepareCommandsSubmission(const QVector<RenderView *> &renderViews);
+    void prepareCommandsSubmission(const std::vector<RenderView *> &renderViews);
     bool executeCommandsSubmission(RenderView *rv);
     bool updateVAOWithAttributes(Geometry *geometry,
                                  const RenderCommand *command,
@@ -291,7 +290,7 @@ public:
         QSurface *surface;
     };
 
-    ViewSubmissionResultData submitRenderViews(const QVector<RenderView *> &renderViews);
+    ViewSubmissionResultData submitRenderViews(const std::vector<RenderView *> &renderViews);
 
     RendererCache *cache() { return &m_cache; }
     void setScreen(QScreen *scr) override;
@@ -303,7 +302,6 @@ public:
 
 private:
 #endif
-    bool canRender() const;
     Profiling::FrameProfiler *activeProfiler() const;
 
     Qt3DCore::QServiceLocator *m_services;
diff --git a/src/plugins/renderers/opengl/renderer/renderqueue.cpp b/src/plugins/renderers/opengl/renderer/renderqueue.cpp
index 15b89da30..fe0513b3b 100644
--- a/src/plugins/renderers/opengl/renderer/renderqueue.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderqueue.cpp
@@ -101,7 +101,7 @@ bool RenderQueue::queueRenderView(RenderView *renderView, uint submissionOrderIn
  * A call to reset is required after rendering of the frame. Otherwise under some
  * conditions the current but then invalidated frame queue could be reused.
  */
-QVector<RenderView *> RenderQueue::nextFrameQueue()
+const std::vector<RenderView *> &RenderQueue::nextFrameQueue() const
 {
     return m_currentWorkQueue;
 }
diff --git a/src/plugins/renderers/opengl/renderer/renderqueue_p.h b/src/plugins/renderers/opengl/renderer/renderqueue_p.h
index 0dcf7b8ee..7f42b25cd 100644
--- a/src/plugins/renderers/opengl/renderer/renderqueue_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderqueue_p.h
@@ -51,7 +51,7 @@
 // We mean it.
 //
 
-#include <QVector>
+#include <vector>
 #include <QtGlobal>
 #include <QMutex>
 
@@ -76,7 +76,7 @@ public:
     bool isFrameQueueComplete() const;
 
     bool queueRenderView(RenderView *renderView, uint submissionOrderIndex);
-    QVector<RenderView *> nextFrameQueue();
+    const std::vector<RenderView *> &nextFrameQueue() const;
     void reset();
 
     void setNoRender();
@@ -91,7 +91,7 @@ private:
     bool m_wasReset;
     int m_targetRenderViewCount;
     int m_currentRenderViewCount;
-    QVector<RenderView *> m_currentWorkQueue;
+    std::vector<RenderView *> m_currentWorkQueue;
     QMutex m_mutex;
 };
 
diff --git a/src/quick3d/imports/scene3d/scene3drenderer.cpp b/src/quick3d/imports/scene3d/scene3drenderer.cpp
index e81a9044c..7b7f46126 100644
--- a/src/quick3d/imports/scene3d/scene3drenderer.cpp
+++ b/src/quick3d/imports/scene3d/scene3drenderer.cpp
@@ -296,7 +296,7 @@ void Scene3DRenderer::beforeSynchronize()
         if (m_skipFrame) {
             m_skipFrame = false;
             ContextSaver saver;
-            static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(m_renderAspect))->renderSynchronous(false);
+            static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(m_renderAspect))->render(false);
             return;
         }
 
@@ -423,7 +423,7 @@ void Scene3DRenderer::render()
 
     // Render Qt3D Scene
     // Qt3D takes care of resetting the GL state to default values
-    static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(m_renderAspect))->renderSynchronous(usesFBO);
+    static_cast<QRenderAspectPrivate*>(QRenderAspectPrivate::get(m_renderAspect))->render(usesFBO);
 
     // We may have called doneCurrent() so restore the context if the rendering surface was changed
     // Note: keep in mind that the ContextSave also restores the surface when destroyed
diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index 8c59468aa..6f849128a 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -139,10 +139,7 @@ public:
     virtual void shutdown() = 0;
     virtual void releaseGraphicsResources() = 0;
 
-    // Threaded renderer
-    virtual void render() = 0;
-    // Synchronous renderer
-    virtual void doRender(bool swapBuffers) = 0;
+    virtual void render(bool swapBuffers) = 0;
 
     virtual void cleanGraphicsResources() = 0;
 
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 5d421dc01..8f30d46f0 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -358,7 +358,7 @@ void QRenderAspectPrivate::frameDone()
 {
     m_renderer->setJobsInLastFrame(m_aspectManager->jobsInLastFrame());
     if (m_renderAfterJobs)
-        m_renderer->doRender(true);
+        m_renderer->render(true);
 }
 
 void QRenderAspectPrivate::createNodeManagers()
@@ -639,9 +639,9 @@ void QRenderAspectPrivate::renderInitialize(QOpenGLContext *context)
 }
 
 /*! \internal */
-void QRenderAspectPrivate::renderSynchronous(bool swapBuffers)
+void QRenderAspectPrivate::render(bool swapBuffers)
 {
-    m_renderer->doRender(swapBuffers);
+    m_renderer->render(swapBuffers);
 }
 
 /*
diff --git a/src/render/frontend/qrenderaspect_p.h b/src/render/frontend/qrenderaspect_p.h
index fbdc0c053..8df8bbca5 100644
--- a/src/render/frontend/qrenderaspect_p.h
+++ b/src/render/frontend/qrenderaspect_p.h
@@ -114,7 +114,7 @@ public:
     void loadSceneParsers();
     void loadRenderPlugin(const QString &pluginName);
     void renderInitialize(QOpenGLContext *context);
-    void renderSynchronous(bool swapBuffers = true);
+    void render(bool swapBuffers = true);
     void renderShutdown();
     void registerBackendType(const QMetaObject &, const Qt3DCore::QBackendNodeMapperPtr &functor);
     std::vector<Qt3DCore::QAspectJobPtr> createGeometryRendererJobs() const;
diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index 9f9837198..11be92153 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -59,8 +59,7 @@ public:
     void initialize() override {}
     void shutdown() override {}
     void releaseGraphicsResources() override {}
-    void render() override {}
-    void doRender(bool swapBuffers) override { Q_UNUSED(swapBuffers); }
+    void render(bool swapBuffers) override { Q_UNUSED(swapBuffers); }
     void cleanGraphicsResources() override {}
     bool isRunning() const override { return true; }
     bool shouldRender() const override { return true; }
diff --git a/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp b/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
index 728648a3c..bb39f235d 100644
--- a/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
+++ b/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
@@ -111,7 +111,7 @@ void tst_RenderQueue::checkOrder()
     }
 
     // THEN
-    QVector<Qt3DRender::Render::OpenGL::RenderView *> frame = renderQueue.nextFrameQueue();
+    const std::vector<Qt3DRender::Render::OpenGL::RenderView *> &frame = renderQueue.nextFrameQueue();
     for (int i = 0; i < 7; ++i) {
         QVERIFY(frame[i] == renderViews[i]);
     }
diff --git a/tests/manual/manual-renderloop/main.cpp b/tests/manual/manual-renderloop/main.cpp
index 274575b48..7c7d525a4 100644
--- a/tests/manual/manual-renderloop/main.cpp
+++ b/tests/manual/manual-renderloop/main.cpp
@@ -102,7 +102,7 @@ public:
         // Submit Render Queues
         Qt3DRender::QRenderAspectPrivate *dRenderAspect = static_cast<decltype(dRenderAspect)>
                 (Qt3DRender::QRenderAspectPrivate::get(m_renderAspect));
-        dRenderAspect->renderSynchronous(true);
+        dRenderAspect->render(true);
     }
 
 private: