Merge remote-tracking branch 5.15 into dev

Change-Id: I2777f6a40b9029ef5569a84e04f9e18a914504e7

6 files changed, 76 insertions, 24 deletions

diff --git a/src/plugins/renderers/opengl/renderer/renderer.cpp b/src/plugins/renderers/opengl/renderer/renderer.cpp
index a50a770eb..2dafa15c5 100644
--- a/src/plugins/renderers/opengl/renderer/renderer.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderer.cpp
@@ -267,19 +267,19 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     , m_lightGathererJob(Render::LightGathererPtr::create())
     , m_renderableEntityFilterJob(Render::RenderableEntityFilterPtr::create())
     , m_computableEntityFilterJob(Render::ComputableEntityFilterPtr::create())
-    , m_bufferGathererJob(SynchronizerJobPtr::create([this] { lookForDirtyBuffers(); }, JobTypes::DirtyBufferGathering))
-    , m_vaoGathererJob(SynchronizerJobPtr::create([this] { lookForAbandonedVaos(); }, JobTypes::DirtyVaoGathering))
-    , m_textureGathererJob(SynchronizerJobPtr::create([this] { lookForDirtyTextures(); }, JobTypes::DirtyTextureGathering))
-    , m_introspectShaderJob(SynchronizerPostFramePtr::create([this] { reloadDirtyShaders(); },
-                                                             [this] (Qt3DCore::QAspectManager *m) { sendShaderChangesToFrontend(m); },
-                                                             JobTypes::DirtyShaderGathering))
-    , m_syncLoadingJobs(SynchronizerJobPtr::create([] {}, JobTypes::SyncLoadingJobs))
-    , m_cacheRenderableEntitiesJob(SynchronizerJobPtr::create(SyncRenderableEntities(m_renderableEntityFilterJob, &m_cache),
-                                                              JobTypes::EntityComponentTypeFiltering))
-    , m_cacheComputableEntitiesJob(SynchronizerJobPtr::create(SyncComputableEntities(m_computableEntityFilterJob, &m_cache),
-                                                              JobTypes::EntityComponentTypeFiltering))
-    , m_cacheLightsJob(SynchronizerJobPtr::create(SyncLightsGatherer(m_lightGathererJob, &m_cache),
-                                                  JobTypes::EntityComponentTypeFiltering))
+    , m_bufferGathererJob(CreateSynchronizerJobPtr([this] { lookForDirtyBuffers(); }, JobTypes::DirtyBufferGathering))
+    , m_vaoGathererJob(CreateSynchronizerJobPtr([this] { lookForAbandonedVaos(); }, JobTypes::DirtyVaoGathering))
+    , m_textureGathererJob(CreateSynchronizerJobPtr([this] { lookForDirtyTextures(); }, JobTypes::DirtyTextureGathering))
+    , m_introspectShaderJob(CreateSynchronizerPostFramePtr([this] { reloadDirtyShaders(); },
+                                                           [this] (Qt3DCore::QAspectManager *m) { sendShaderChangesToFrontend(m); },
+                                                           JobTypes::DirtyShaderGathering))
+    , m_syncLoadingJobs(CreateSynchronizerJobPtr([] {}, JobTypes::SyncLoadingJobs))
+    , m_cacheRenderableEntitiesJob(CreateSynchronizerJobPtr(SyncRenderableEntities(m_renderableEntityFilterJob, &m_cache),
+                                                            JobTypes::EntityComponentTypeFiltering))
+    , m_cacheComputableEntitiesJob(CreateSynchronizerJobPtr(SyncComputableEntities(m_computableEntityFilterJob, &m_cache),
+                                                            JobTypes::EntityComponentTypeFiltering))
+    , m_cacheLightsJob(CreateSynchronizerJobPtr(SyncLightsGatherer(m_lightGathererJob, &m_cache),
+                                                JobTypes::EntityComponentTypeFiltering))
     , m_ownedContext(false)
     , m_offscreenHelper(nullptr)
     , m_glResourceManagers(nullptr)
@@ -300,6 +300,7 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     m_updateWorldBoundingVolumeJob->addDependency(m_calculateBoundingVolumeJob);
     m_expandBoundingVolumeJob->addDependency(m_updateWorldBoundingVolumeJob);
     m_updateShaderDataTransformJob->addDependency(m_worldTransformJob);
+    m_updateLevelOfDetailJob->addDependency(m_expandBoundingVolumeJob);
     m_pickBoundingVolumeJob->addDependency(m_expandBoundingVolumeJob);
     m_rayCastingJob->addDependency(m_expandBoundingVolumeJob);
     // m_calculateBoundingVolumeJob's dependency on m_updateTreeEnabledJob is set in renderBinJobs
@@ -1178,6 +1179,10 @@ void Renderer::reloadDirtyShaders()
                 HShader shaderHandle = m_nodesManager->shaderManager()->lookupHandle(renderPass->shaderProgram());
                 Shader *shader = m_nodesManager->shaderManager()->data(shaderHandle);
 
+                // Shader could be null if the pass doesn't reference one yet
+                if (!shader)
+                    continue;
+
                 ShaderBuilder *shaderBuilder = nullptr;
                 for (const HShaderBuilder &builderHandle : activeBuilders) {
                     ShaderBuilder *builder = m_nodesManager->shaderBuilderManager()->data(builderHandle);
@@ -1205,7 +1210,7 @@ void Renderer::reloadDirtyShaders()
                     }
                 }
 
-                if (shader != nullptr && shader->isDirty())
+                if (shader->isDirty())
                     loadShader(shader, shaderHandle);
             }
         }
@@ -1393,13 +1398,15 @@ void Renderer::updateGLResources()
             if (texture ==  nullptr)
                 continue;
 
-            // Create or Update GLTexture (the GLTexture instance is created if required
-            // and all things that can take place without a GL context are done here)
+            // Create or Update GLTexture (the GLTexture instance is created
+            // (not the underlying GL instance) if required and all things that
+            // can take place without a GL context are done here)
             updateTexture(texture);
         }
         // We want to upload textures data at this point as the SubmissionThread and
         // AspectThread are locked ensuring no races between Texture/TextureImage and
         // GLTexture
+        QNodeIdVector updatedTexturesForFrame;
         if (m_submissionContext != nullptr) {
             GLTextureManager *glTextureManager = m_glResourceManagers->glTextureManager();
             const QVector<HGLTexture> glTextureHandles = glTextureManager->activeHandles();
@@ -1421,16 +1428,28 @@ void Renderer::updateGLResources()
                     updateInfo.handleType = QAbstractTexture::OpenGLTextureId;
                     updateInfo.handle = info.texture ? QVariant(info.texture->textureId()) : QVariant();
                     m_updatedTextureProperties.push_back({updateInfo, referenceTextureIds});
+                    updatedTexturesForFrame += referenceTextureIds;
                 }
             }
         }
 
+        // If the underlying GL Texture was for whatever reason recreated, we need to make sure
+        // that if it is used as a color attachment, we rebuild the FBO next time it is used
+        m_submissionContext->setUpdatedTexture(std::move(updatedTexturesForFrame));
+
         // Record ids of texture to cleanup while we are still blocking the aspect thread
         m_textureIdsToCleanup += m_nodesManager->textureManager()->takeTexturesIdsToCleanup();
     }
 
     // Record list of buffer that might need uploading
     lookForDownloadableBuffers();
+
+    // Remove destroyed FBOs
+    {
+        const QNodeIdVector destroyedRenderTargetIds = m_nodesManager->renderTargetManager()->takeRenderTargetIdsToCleanup();
+        for (const Qt3DCore::QNodeId &renderTargetId : destroyedRenderTargetIds)
+            m_submissionContext->releaseRenderTarget(renderTargetId);
+    }
 }
 
 // Render Thread
@@ -1569,6 +1588,9 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
         // If the RenderView has a RenderStateSet defined
         const RenderView *renderView = renderViews.at(i);
 
+        if (renderView->shouldSkipSubmission())
+            continue;
+
         // Check if using the same surface as the previous RenderView.
         // If not, we have to free up the context from the previous surface
         // and make the context current on the new surface
diff --git a/src/plugins/renderers/opengl/renderer/renderer_p.h b/src/plugins/renderers/opengl/renderer/renderer_p.h
index 5999aabe3..8ab56bd01 100644
--- a/src/plugins/renderers/opengl/renderer/renderer_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderer_p.h
@@ -164,6 +164,8 @@ using RenderableEntityFilterPtr = FilterEntityByComponentJobPtr<Render::Geometry
 
 using SynchronizerJobPtr = GenericLambdaJobPtr<std::function<void()>>;
 using SynchronizerPostFramePtr = GenericLambdaJobAndPostFramePtr<std::function<void ()>, std::function<void (Qt3DCore::QAspectManager *)>>;
+#define CreateSynchronizerPostFramePtr(lambda, postlambda, type) \
+    SynchronizerPostFramePtr::create(lambda, postlambda, type, #type)
 
 namespace Debug {
 class ImGuiRenderer;
@@ -326,6 +328,7 @@ public:
     RendererCache *cache() { return &m_cache; }
     void setScreen(QScreen *scr) override;
     QScreen *screen() const override;
+    NodeManagers *nodesManager() const { return m_nodesManager; }
 
 #ifdef QT3D_RENDER_UNIT_TESTS
 public:
diff --git a/src/plugins/renderers/opengl/renderer/renderview.cpp b/src/plugins/renderers/opengl/renderer/renderview.cpp
index f18f1a06a..47f4beffd 100644
--- a/src/plugins/renderers/opengl/renderer/renderview.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderview.cpp
@@ -1213,6 +1213,29 @@ void RenderView::setHasBlitFramebufferInfo(bool hasBlitFramebufferInfo)
     m_hasBlitFramebufferInfo = hasBlitFramebufferInfo;
 }
 
+bool RenderView::shouldSkipSubmission() const
+{
+    if (!m_commands.empty())
+        return false;
+
+    if (m_hasBlitFramebufferInfo)
+        return false;
+
+    if (m_isDownloadBuffersEnable)
+        return false;
+
+    if (m_showDebugOverlay)
+        return false;
+
+    if (!m_waitFences.empty() || !m_insertFenceIds.empty())
+        return false;
+
+    if (m_clearBuffer != QClearBuffers::None)
+        return false;
+
+    return true;
+}
+
 BlitFramebufferInfo RenderView::blitFrameBufferInfo() const
 {
     return m_blitFrameBufferInfo;
diff --git a/src/plugins/renderers/opengl/renderer/renderview_p.h b/src/plugins/renderers/opengl/renderer/renderview_p.h
index 40e7a77fe..adab30f4e 100644
--- a/src/plugins/renderers/opengl/renderer/renderview_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderview_p.h
@@ -289,6 +289,8 @@ public:
     bool hasBlitFramebufferInfo() const;
     void setHasBlitFramebufferInfo(bool hasBlitFramebufferInfo);
 
+    bool shouldSkipSubmission() const;
+
 private:
     void setShaderAndUniforms(RenderCommand *command,
                               ParameterInfoList &parameters,
diff --git a/src/plugins/renderers/opengl/renderer/renderviewbuilder.cpp b/src/plugins/renderers/opengl/renderer/renderviewbuilder.cpp
index 1e16209c6..a80fbe445 100644
--- a/src/plugins/renderers/opengl/renderer/renderviewbuilder.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderviewbuilder.cpp
@@ -463,8 +463,8 @@ RenderViewBuilder::RenderViewBuilder(Render::FrameGraphNode *leafNode, int rende
     , m_renderViewJob(RenderViewInitializerJobPtr::create())
     , m_filterEntityByLayerJob()
     , m_frustumCullingJob(new Render::FrustumCullingJob())
-    , m_syncPreFrustumCullingJob(SynchronizerJobPtr::create(SyncPreFrustumCulling(m_renderViewJob, m_frustumCullingJob), JobTypes::SyncFrustumCulling))
-    , m_setClearDrawBufferIndexJob(SynchronizerJobPtr::create(SetClearDrawBufferIndex(m_renderViewJob), JobTypes::ClearBufferDrawIndex))
+    , m_syncPreFrustumCullingJob(CreateSynchronizerJobPtr(SyncPreFrustumCulling(m_renderViewJob, m_frustumCullingJob), JobTypes::SyncFrustumCulling))
+    , m_setClearDrawBufferIndexJob(CreateSynchronizerJobPtr(SetClearDrawBufferIndex(m_renderViewJob), JobTypes::ClearBufferDrawIndex))
     , m_syncFilterEntityByLayerJob()
     , m_filterProximityJob(Render::FilterProximityDistanceJobPtr::create())
 {
@@ -558,7 +558,7 @@ void RenderViewBuilder::prepareJobs()
             auto renderViewCommandBuilder = Render::OpenGL::RenderViewCommandBuilderJobPtr::create();
             m_renderViewCommandBuilderJobs.push_back(renderViewCommandBuilder);
         }
-        m_syncRenderViewPreCommandBuildingJob = SynchronizerJobPtr::create(SyncPreCommandBuilding(m_renderViewJob,
+        m_syncRenderViewPreCommandBuildingJob = CreateSynchronizerJobPtr(SyncPreCommandBuilding(m_renderViewJob,
                                                                                                   m_renderViewCommandBuilderJobs,
                                                                                                   m_renderer,
                                                                                                   m_leafNode),
@@ -593,7 +593,7 @@ void RenderViewBuilder::prepareJobs()
                 materialGatherer->setHandles(materialHandles.mid(i * elementsPerJob, elementsPerJob));
             m_materialGathererJobs.push_back(materialGatherer);
         }
-        m_syncMaterialGathererJob = SynchronizerJobPtr::create(SyncMaterialParameterGatherer(m_materialGathererJobs,
+        m_syncMaterialGathererJob = CreateSynchronizerJobPtr(SyncMaterialParameterGatherer(m_materialGathererJobs,
                                                                                              m_renderer,
                                                                                              m_leafNode),
                                                                JobTypes::SyncMaterialGatherer);
@@ -602,13 +602,13 @@ void RenderViewBuilder::prepareJobs()
     if (m_layerCacheNeedsToBeRebuilt) {
         m_filterEntityByLayerJob = Render::FilterLayerEntityJobPtr::create();
         m_filterEntityByLayerJob->setManager(m_renderer->nodeManagers());
-        m_syncFilterEntityByLayerJob = SynchronizerJobPtr::create(SyncFilterEntityByLayer(m_filterEntityByLayerJob,
+        m_syncFilterEntityByLayerJob = CreateSynchronizerJobPtr(SyncFilterEntityByLayer(m_filterEntityByLayerJob,
                                                                                           m_renderer,
                                                                                           m_leafNode),
                                                                   JobTypes::SyncFilterEntityByLayer);
     }
 
-    m_syncRenderViewPreCommandUpdateJob = SynchronizerJobPtr::create(SyncRenderViewPreCommandUpdate(m_renderViewJob,
+    m_syncRenderViewPreCommandUpdateJob = CreateSynchronizerJobPtr(SyncRenderViewPreCommandUpdate(m_renderViewJob,
                                                                                                     m_frustumCullingJob,
                                                                                                     m_filterProximityJob,
                                                                                                     m_materialGathererJobs,
@@ -619,12 +619,12 @@ void RenderViewBuilder::prepareJobs()
                                                                                                     m_renderCommandCacheNeedsToBeRebuilt),
                                                                      JobTypes::SyncRenderViewPreCommandUpdate);
 
-    m_syncRenderViewPostCommandUpdateJob = SynchronizerJobPtr::create(SyncRenderViewPostCommandUpdate(m_renderViewJob,
+    m_syncRenderViewPostCommandUpdateJob = CreateSynchronizerJobPtr(SyncRenderViewPostCommandUpdate(m_renderViewJob,
                                                                                                       m_renderViewCommandUpdaterJobs,
                                                                                                       m_renderer),
                                                                       JobTypes::SyncRenderViewPostCommandUpdate);
 
-    m_syncRenderViewPostInitializationJob = SynchronizerJobPtr::create(SyncRenderViewPostInitialization(m_renderViewJob,
+    m_syncRenderViewPostInitializationJob = CreateSynchronizerJobPtr(SyncRenderViewPostInitialization(m_renderViewJob,
                                                                                                         m_frustumCullingJob,
                                                                                                         m_filterEntityByLayerJob,
                                                                                                         m_filterProximityJob,
diff --git a/src/plugins/renderers/opengl/renderer/renderviewbuilder_p.h b/src/plugins/renderers/opengl/renderer/renderviewbuilder_p.h
index 98202670e..54fc98352 100644
--- a/src/plugins/renderers/opengl/renderer/renderviewbuilder_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderviewbuilder_p.h
@@ -75,6 +75,8 @@ namespace OpenGL {
 class Renderer;
 
 using SynchronizerJobPtr = GenericLambdaJobPtr<std::function<void()>>;
+#define CreateSynchronizerJobPtr(lambda, type) \
+    SynchronizerJobPtr::create(lambda, type, #type)
 
 class Q_AUTOTEST_EXPORT RenderViewBuilder
 {