Make findTechniqueForEffect a free function and small cleanups

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

4 files changed, 75 insertions, 33 deletions

diff --git a/src/render/backend/jobs/renderviewjobutils.cpp b/src/render/backend/jobs/renderviewjobutils.cpp
index 95b90b19d..fc43d159a 100644
--- a/src/render/backend/jobs/renderviewjobutils.cpp
+++ b/src/render/backend/jobs/renderviewjobutils.cpp
@@ -41,6 +41,7 @@
 
 #include "renderviewjobutils_p.h"
 
+#include <Qt3DRenderer/qopenglfilter.h>
 #include <Qt3DRenderer/sphere.h>
 
 #include <Qt3DRenderer/private/cameraselectornode_p.h>
@@ -54,6 +55,7 @@
 #include <Qt3DRenderer/private/techniquefilternode_p.h>
 #include <Qt3DRenderer/private/viewportnode_p.h>
 
+
 QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
@@ -191,6 +193,67 @@ void preprocessRenderTree(RenderView *rv, const RenderEntity *node)
         preprocessRenderTree(rv, child);
 }
 
+/*!
+    \internal
+    Searches the \a renderer for the best matching RenderTechnique from
+    \a effect specified by the \a renderView.
+*/
+RenderTechnique *findTechniqueForEffect(Renderer *renderer,
+                                        RenderView *renderView,
+                                        RenderEffect *effect)
+{
+    if (!effect)
+        return Q_NULLPTR;
+
+    // Iterate through the techniques in the effect
+    Q_FOREACH (const QNodeUuid &techniqueId, effect->techniques()) {
+        RenderTechnique *technique = renderer->techniqueManager()->lookupResource(techniqueId);
+
+        if (!technique)
+            continue;
+
+        if (*renderer->contextInfo() == *technique->openGLFilter()) {
+
+            // If no techniqueFilter is present, we return the technique as it satisfies OpenGL version
+            const TechniqueFilter *techniqueFilter = renderView->techniqueFilter();
+            bool foundMatch = (techniqueFilter == Q_NULLPTR || techniqueFilter->filters().isEmpty());
+            if (foundMatch)
+                return technique;
+
+            // There is a technique filter so we need to check for a technique with suitable criteria.
+            // Check for early bail out if the technique doesn't have sufficient number of criteria and
+            // can therefore never satisfy the filter
+            if (technique->annotations().size() < techniqueFilter->filters().size())
+                continue;
+
+            // Iterate through the filter criteria and for each one search for a criteria on the
+            // technique that satisfies it
+            Q_FOREACH (const QUuid &filterAnnotationId, techniqueFilter->filters()) {
+                foundMatch = false;
+                RenderAnnotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId);
+
+                Q_FOREACH (const QUuid &techniqueAnnotationId, technique->annotations()) {
+                    RenderAnnotation *techniqueAnnotation = renderer->criterionManager()->lookupResource(techniqueAnnotationId);
+                    if ((foundMatch = (*techniqueAnnotation == *filterAnnotation)))
+                        break;
+                }
+
+                if (!foundMatch) {
+                    // No match for TechniqueFilter criterion in any of the technique's criteria.
+                    // So no way this can match. Don't bother checking the rest of the criteria.
+                    break;
+                }
+            }
+
+            if (foundMatch)
+                return technique; // All criteria matched - we have a winner!
+        }
+    }
+
+    // We failed to find a suitable technique to use :(
+    return Q_NULLPTR;
+}
+
 } // namespace Render
 } // namespace Qt3D
 
diff --git a/src/render/backend/jobs/renderviewjobutils_p.h b/src/render/backend/jobs/renderviewjobutils_p.h
index 9adad470f..afbd9071e 100644
--- a/src/render/backend/jobs/renderviewjobutils_p.h
+++ b/src/render/backend/jobs/renderviewjobutils_p.h
@@ -49,7 +49,10 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 namespace Render {
 
+class RenderEffect;
 class RenderEntity;
+class Renderer;
+class RenderTechnique;
 class RenderView;
 class FrameGraphNode;
 
@@ -58,6 +61,10 @@ Q_AUTOTEST_EXPORT void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv,
 
 Q_AUTOTEST_EXPORT void preprocessRenderTree(RenderView *rv, const RenderEntity *node);
 
+Q_AUTOTEST_EXPORT RenderTechnique *findTechniqueForEffect(Renderer *renderer,
+                                                          RenderView *renderView,
+                                                          RenderEffect *effect);
+
 } // namespace Render
 } // namespace Qt3D
 
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 55a92d01a..28d29ed95 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -42,7 +42,6 @@
 
 #include "renderview_p.h"
 #include <Qt3DRenderer/qmaterial.h>
-#include <Qt3DRenderer/qopenglfilter.h>
 #include <Qt3DRenderer/renderlogging.h>
 #include <Qt3DRenderer/qtexture.h>
 #include <Qt3DRenderer/qrendertarget.h>
@@ -78,6 +77,9 @@
 #include <Qt3DRenderer/qscissortest.h>
 #include <Qt3DRenderer/qstenciltest.h>
 #include <Qt3DRenderer/qalphacoverage.h>
+
+// TODO: Move out once this is all refactored
+#include <Qt3DRenderer/private/renderviewjobutils_p.h>
 #include <Qt3DRenderer/private/blendstate_p.h>
 
 #include <Qt3DCore/qentity.h>
@@ -335,7 +337,8 @@ void RenderView::buildRenderCommands(RenderEntity *node)
                 RenderEffect *effect = Q_NULLPTR;
                 if ((material = node->renderComponent<RenderMaterial>()) != Q_NULLPTR)
                     effect = m_renderer->effectManager()->lookupResource(material->effect());
-                RenderTechnique *technique = findTechniqueForEffect(effect);
+                RenderTechnique *technique = findTechniqueForEffect(m_renderer, this, effect);
+
                 QList<RenderRenderPass *> passes = findRenderPassesForTechnique(technique);
                 if (passes.isEmpty()) {
                     material = m_renderer->materialManager()->data(m_renderer->defaultMaterialHandle());
@@ -372,36 +375,6 @@ const AttachmentPack &RenderView::attachmentPack() const
     return m_attachmentPack;
 }
 
-RenderTechnique *RenderView::findTechniqueForEffect(RenderEffect *effect)
-{
-    if (effect != Q_NULLPTR) {
-        Q_FOREACH (const QNodeUuid &techniqueId, effect->techniques()) {
-            RenderTechnique *technique = m_renderer->techniqueManager()->lookupResource(techniqueId);
-            if (technique != Q_NULLPTR &&
-                    *m_renderer->contextInfo() == *technique->openGLFilter()) {
-                // If no techniqueFilter is present, we return the technique as it satisfies OpenGL version
-                bool findMatch = (m_data->m_techniqueFilter == Q_NULLPTR || m_data->m_techniqueFilter->filters().size() == 0) ? true : false;
-                if (!findMatch && technique->annotations().size() >= m_data->m_techniqueFilter->filters().size()) {
-                    Q_FOREACH (const QNodeUuid &refCritId, m_data->m_techniqueFilter->filters()) {
-                        RenderAnnotation *refCriterion = m_renderer->criterionManager()->lookupResource(refCritId);
-                        findMatch = false;
-                        Q_FOREACH (const QNodeUuid &critId, technique->annotations()) {
-                            RenderAnnotation *rCrit = m_renderer->criterionManager()->lookupResource(critId);
-                            if ((findMatch = (*rCrit == *refCriterion)))
-                                break;
-                        }
-                        if (!findMatch) // No match for TechniqueFilter criterion in any of the technique's criteria
-                            break;
-                    }
-                }
-                if (findMatch) // If all criteria matched
-                    return technique;
-            }
-        }
-    }
-    return Q_NULLPTR;
-}
-
 QList<RenderRenderPass *> RenderView::findRenderPassesForTechnique(RenderTechnique *technique)
 {
     QList<RenderRenderPass *> passes;
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index 0c1f2b9f3..a8dca3a98 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -191,7 +191,6 @@ public:
     void addSortCriteria(const QList<QNodeUuid> &sortMethodUid) { m_data->m_sortingCriteria.append(sortMethodUid); }
 
 private:
-    RenderTechnique *findTechniqueForEffect(RenderEffect *effect);
     QList<RenderRenderPass *> findRenderPassesForTechnique(RenderTechnique *technique);
     void setShaderAndUniforms(RenderCommand *command, RenderRenderPass *pass, QHash<QString, QVariant> &parameters, const QMatrix4x4 &worldTransform);
     QHash<QString, QVariant> parametersFromMaterialEffectTechnique(RenderMaterial *material, RenderEffect *effect, RenderTechnique *technique);