ResourceAccessor: make it work with the modular renderer architecture

This makes Scene2D work again. Tests restored as well.

Change-Id: I4082d362c999a674be2debc297d59075f4b7c9e9

10 files changed, 125 insertions, 85 deletions

diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index 8bbfcd548..af0e8ed5c 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -65,6 +65,7 @@ QT_BEGIN_NAMESPACE
 class QSurface;
 class QSize;
 class QScreen;
+class QOpenGLTexture;
 
 namespace Qt3DCore {
 class QAbstractFrameAdvanceService;
@@ -87,6 +88,7 @@ class RenderSettings;
 class BackendNode;
 class OffscreenSurfaceHelper;
 class Shader;
+class RenderBackendResourceAccessor;
 
 class Q_3DRENDERSHARED_PRIVATE_EXPORT AbstractRenderer
 {
@@ -176,10 +178,12 @@ public:
 
     virtual QVariant executeCommand(const QStringList &args) = 0;
 
-    // For QtQuick rendering
+    // For QtQuick rendering (Scene2D)
     virtual void setOpenGLContext(QOpenGLContext *ctx) = 0;
     virtual void setScreen(QScreen *) {}
     virtual QScreen *screen() const { return nullptr; }
+    virtual bool accessOpenGLTexture(Qt3DCore::QNodeId nodeId, QOpenGLTexture **texture, QMutex **lock, bool readonly) = 0;
+    virtual QSharedPointer<RenderBackendResourceAccessor> resourceAccessor() const = 0;
 
     virtual void setOffscreenSurfaceHelper(OffscreenSurfaceHelper *helper) = 0;
     virtual QSurfaceFormat format() = 0;
diff --git a/src/render/backend/backendnode.cpp b/src/render/backend/backendnode.cpp
index 642f6e44d..f85ece1b9 100644
--- a/src/render/backend/backendnode.cpp
+++ b/src/render/backend/backendnode.cpp
@@ -82,10 +82,9 @@ void BackendNode::markDirty(AbstractRenderer::BackendNodeDirtySet changes)
     m_renderer->markDirty(changes, this);
 }
 
-QSharedPointer<RenderBackendResourceAccessor> BackendNode::resourceAccessor()
+QSharedPointer<RenderBackendResourceAccessor> BackendNode::resourceAccessor() const
 {
-    Render::Renderer *r = static_cast<Render::Renderer *>(renderer());
-    return r->nodeManagers()->resourceAccessor();
+    return m_renderer->resourceAccessor();
 }
 
 void BackendNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
diff --git a/src/render/backend/backendnode_p.h b/src/render/backend/backendnode_p.h
index 37f8305af..3b880f759 100644
--- a/src/render/backend/backendnode_p.h
+++ b/src/render/backend/backendnode_p.h
@@ -81,7 +81,7 @@ public:
     void setRenderer(AbstractRenderer *renderer);
     AbstractRenderer *renderer() const;
 
-    QSharedPointer<RenderBackendResourceAccessor> resourceAccessor();
+    QSharedPointer<RenderBackendResourceAccessor> resourceAccessor() const;
 
 protected:
     explicit BackendNode(Qt3DCore::QBackendNodePrivate &dd);
diff --git a/src/render/backend/nodemanagers.cpp b/src/render/backend/nodemanagers.cpp
index 8603d4fb9..df660a19e 100644
--- a/src/render/backend/nodemanagers.cpp
+++ b/src/render/backend/nodemanagers.cpp
@@ -46,7 +46,6 @@
 #include <Qt3DRender/private/techniquemanager_p.h>
 #include <Qt3DRender/private/armature_p.h>
 #include <Qt3DRender/private/skeleton_p.h>
-#include <private/resourceaccessor_p.h>
 
 
 QT_BEGIN_NAMESPACE
@@ -92,7 +91,6 @@ NodeManagers::NodeManagers()
     , m_skeletonManager(new SkeletonManager())
     , m_jointManager(new JointManager())
     , m_shaderImageManager(new ShaderImageManager())
-    , m_resourceAccessor(new ResourceAccessor(this))
 {
 }
 
@@ -139,11 +137,6 @@ NodeManagers::~NodeManagers()
     delete m_shaderImageManager;
 }
 
-QSharedPointer<ResourceAccessor> NodeManagers::resourceAccessor()
-{
-    return m_resourceAccessor;
-}
-
 template<>
 CameraManager *NodeManagers::manager<CameraLens>() const noexcept
 {
diff --git a/src/render/backend/nodemanagers_p.h b/src/render/backend/nodemanagers_p.h
index 62a73b510..e6f7469de 100644
--- a/src/render/backend/nodemanagers_p.h
+++ b/src/render/backend/nodemanagers_p.h
@@ -140,7 +140,6 @@ class Skeleton;
 class Joint;
 class ShaderImage;
 
-class ResourceAccessor;
 
 class Q_3DRENDERSHARED_PRIVATE_EXPORT NodeManagers
 {
@@ -219,8 +218,6 @@ public:
     inline JointManager *jointManager() const noexcept { return m_jointManager; }
     inline ShaderImageManager *shaderImageManager() const noexcept { return m_shaderImageManager; }
 
-    QSharedPointer<ResourceAccessor> resourceAccessor();
-
 private:
     CameraManager *m_cameraManager;
     EntityManager *m_renderNodesManager;
@@ -258,8 +255,6 @@ private:
     SkeletonManager *m_skeletonManager;
     JointManager *m_jointManager;
     ShaderImageManager *m_shaderImageManager;
-
-    QSharedPointer<ResourceAccessor> m_resourceAccessor;
 };
 
 // Specializations
diff --git a/src/render/backend/resourceaccessor.cpp b/src/render/backend/resourceaccessor.cpp
index af19546b7..846caca58 100644
--- a/src/render/backend/resourceaccessor.cpp
+++ b/src/render/backend/resourceaccessor.cpp
@@ -40,10 +40,11 @@
 
 #include <private/qrendertargetoutput_p.h>
 #include <private/nodemanagers_p.h>
-#include <private/texture_p.h>
+#include <private/glresourcemanagers_p.h>
 #include <private/rendertargetoutput_p.h>
 #include <private/managers_p.h>
 
+#include <Qt3DRender/qt3drender-config.h>
 #include <QtCore/qmutex.h>
 
 QT_BEGIN_NAMESPACE
@@ -56,70 +57,63 @@ RenderBackendResourceAccessor::~RenderBackendResourceAccessor()
 
 }
 
-ResourceAccessor::ResourceAccessor(NodeManagers *mgr)
-//    : m_glTextureManager(mgr->glTextureManager())
-//    , m_textureManager(mgr->textureManager())
-//    , m_attachmentManager(mgr->attachmentManager())
-//    , m_entityManager(mgr->renderNodesManager())
+ResourceAccessor::ResourceAccessor(AbstractRenderer *renderer, NodeManagers *mgr)
+    : m_renderer(renderer)
+    , m_textureManager(mgr->textureManager())
+    , m_attachmentManager(mgr->attachmentManager())
+    , m_entityManager(mgr->renderNodesManager())
 {
 
 }
 
 // called by render plugins from arbitrary thread
-bool ResourceAccessor::accessResource(ResourceType type, Qt3DCore::QNodeId nodeId, void **handle, QMutex **lock)
+bool ResourceAccessor::accessResource(ResourceType type,
+                                      Qt3DCore::QNodeId nodeId,
+                                      void **handle,
+                                      QMutex **lock)
 {
-//    switch (type) {
-
-//    case RenderBackendResourceAccessor::OGLTextureWrite:
-//        Q_FALLTHROUGH();
-//    case RenderBackendResourceAccessor::OGLTextureRead:
-//    {
-//        Texture *tex = m_textureManager->lookupResource(nodeId);
-//        if (!tex)
-//            return false;
-
-//        GLTexture *glTex = m_glTextureManager->lookupResource(tex->peerId());
-//        if (!glTex)
-//            return false;
-
-//        if (glTex->isDirty())
-//            return false;
-
-//        if (type == RenderBackendResourceAccessor::OGLTextureWrite)
-//            glTex->setExternalRenderingEnabled(true);
-
-//        QOpenGLTexture **glTextureHandle = reinterpret_cast<QOpenGLTexture **>(handle);
-//        *glTextureHandle = glTex->getGLTexture();
-
-//        if (type == RenderBackendResourceAccessor::OGLTextureWrite)
-//            *lock = glTex->externalRenderingLock();
-
-//        return true;
-//    }
-
-//    case RenderBackendResourceAccessor::OutputAttachment: {
-//        RenderTargetOutput *output = m_attachmentManager->lookupResource(nodeId);
-//        if (output) {
-//            Attachment **attachmentData = reinterpret_cast<Attachment **>(handle);
-//            *attachmentData = output->attachment();
-//            return true;
-//        }
-//        break;
-//    }
-
-//    case RenderBackendResourceAccessor::EntityHandle: {
-//        Entity *entity = m_entityManager->lookupResource(nodeId);
-//        if (entity) {
-//            Entity **pEntity = reinterpret_cast<Entity **>(handle);
-//            *pEntity = entity;
-//            return true;
-//        }
-//        break;
-//    }
-
-//    default:
-//        break;
-//    }
+    switch (type) {
+
+    // This is purely made so that Scene2D works, this should be completely
+    // redesigned to avoid introducing this kind of coupling and reliance on
+    // OpenGL
+    case RenderBackendResourceAccessor::OGLTextureWrite:
+        Q_FALLTHROUGH();
+    case RenderBackendResourceAccessor::OGLTextureRead:
+    {
+        if (m_renderer->api() != AbstractRenderer::OpenGL) {
+            qWarning() << "Renderer plugin is not compatible with Scene2D";
+            return false;
+        }
+        return m_renderer->accessOpenGLTexture(nodeId,
+                                               reinterpret_cast<QOpenGLTexture **>(handle),
+                                               lock,
+                                               type == RenderBackendResourceAccessor::OGLTextureRead);
+    }
+
+    case RenderBackendResourceAccessor::OutputAttachment: {
+        RenderTargetOutput *output = m_attachmentManager->lookupResource(nodeId);
+        if (output) {
+            Attachment **attachmentData = reinterpret_cast<Attachment **>(handle);
+            *attachmentData = output->attachment();
+            return true;
+        }
+        break;
+    }
+
+    case RenderBackendResourceAccessor::EntityHandle: {
+        Entity *entity = m_entityManager->lookupResource(nodeId);
+        if (entity) {
+            Entity **pEntity = reinterpret_cast<Entity **>(handle);
+            *pEntity = entity;
+            return true;
+        }
+        break;
+    }
+
+    default:
+        break;
+    }
     return false;
 }
 
diff --git a/src/render/backend/resourceaccessor_p.h b/src/render/backend/resourceaccessor_p.h
index 6ceb8677b..0645ecfba 100644
--- a/src/render/backend/resourceaccessor_p.h
+++ b/src/render/backend/resourceaccessor_p.h
@@ -68,6 +68,7 @@ class AttachmentManager;
 class GLTextureManager;
 class EntityManager;
 class NodeManagers;
+class AbstractRenderer;
 
 class RenderBackendResourceAccessor
 {
@@ -86,13 +87,13 @@ public:
 class Q_3DRENDERSHARED_PRIVATE_EXPORT ResourceAccessor : public RenderBackendResourceAccessor
 {
 public:
-    ResourceAccessor(NodeManagers *mgr);
+    ResourceAccessor(AbstractRenderer *renderer, NodeManagers *mgr);
     bool accessResource(ResourceType type, Qt3DCore::QNodeId nodeId, void **handle, QMutex **lock) final;
 private:
-//    GLTextureManager *m_glTextureManager;
-//    TextureManager *m_textureManager;
-//    AttachmentManager *m_attachmentManager;
-//    EntityManager *m_entityManager;
+    AbstractRenderer *m_renderer;
+    TextureManager *m_textureManager;
+    AttachmentManager *m_attachmentManager;
+    EntityManager *m_entityManager;
 };
 
 } // namespace Render
diff --git a/src/render/renderers/opengl/renderer/renderer.cpp b/src/render/renderers/opengl/renderer/renderer.cpp
index 3b986582b..8b0b80abf 100644
--- a/src/render/renderers/opengl/renderer/renderer.cpp
+++ b/src/render/renderers/opengl/renderer/renderer.cpp
@@ -96,6 +96,7 @@
 #include <Qt3DRender/private/commandexecuter_p.h>
 
 #include <Qt3DRender/private/glresourcemanagers_p.h>
+#include <Qt3DRender/private/resourceaccessor_p.h>
 
 #include <Qt3DRender/qcameralens.h>
 #include <Qt3DCore/private/qeventfilterservice_p.h>
@@ -364,6 +365,7 @@ void Renderer::setNodeManagers(NodeManagers *managers)
 {
     m_nodesManager = managers;
     m_glResourceManagers = new GLResourceManagers();
+    m_scene2DResourceAccessor.reset(new ResourceAccessor(this, m_nodesManager));
 
     m_updateShaderDataTransformJob->setManagers(m_nodesManager);
     m_cleanupJob->setManagers(m_nodesManager);
@@ -435,6 +437,39 @@ QScreen *Renderer::screen() const
     return m_screen;
 }
 
+bool Renderer::accessOpenGLTexture(Qt3DCore::QNodeId nodeId,
+                                   QOpenGLTexture **texture,
+                                   QMutex **lock,
+                                   bool readonly)
+{
+    Texture *tex = m_nodesManager->textureManager()->lookupResource(nodeId);
+    if (!tex)
+        return false;
+
+    GLTexture *glTex = m_glResourceManagers->glTextureManager()->lookupResource(tex->peerId());
+    if (!glTex)
+        return false;
+
+    if (glTex->isDirty())
+        return false;
+
+    if (!readonly)
+        glTex->setExternalRenderingEnabled(true);
+
+    GLTexture::TextureUpdateInfo texInfo = glTex->createOrUpdateGLTexture();
+    *texture = texInfo.texture;
+
+    if (!readonly)
+        *lock = glTex->externalRenderingLock();
+
+    return true;
+}
+
+QSharedPointer<RenderBackendResourceAccessor> Renderer::resourceAccessor() const
+{
+    return m_scene2DResourceAccessor;
+}
+
 // Called in RenderThread context by the run method of RenderThread
 // RenderThread has locked the mutex already and unlocks it when this
 // method termintates
@@ -864,6 +899,7 @@ void Renderer::enqueueRenderView(Render::RenderView *renderView, int submitOrder
 }
 
 bool Renderer::canRender() const
+
 {
     // Make sure that we've not been told to terminate
     if (m_renderThread && !m_running.loadRelaxed()) {
diff --git a/src/render/renderers/opengl/renderer/renderer_p.h b/src/render/renderers/opengl/renderer/renderer_p.h
index b423252ca..b9372dce9 100644
--- a/src/render/renderers/opengl/renderer/renderer_p.h
+++ b/src/render/renderers/opengl/renderer/renderer_p.h
@@ -151,6 +151,7 @@ class PickEventFilter;
 class NodeManagers;
 class GLResourceManagers;
 class GLShader;
+class ResourceAccessor;
 
 class UpdateLevelOfDetailJob;
 typedef QSharedPointer<UpdateLevelOfDetailJob> UpdateLevelOfDetailJobPtr;
@@ -276,7 +277,15 @@ public:
     bool requiresVAOAttributeUpdate(Geometry *geometry,
                                     const RenderCommand *command) const;
 
+    // For Scene2D rendering
     void setOpenGLContext(QOpenGLContext *context) override;
+    bool accessOpenGLTexture(Qt3DCore::QNodeId nodeId,
+                             QOpenGLTexture **texture,
+                             QMutex **lock,
+                             bool readonly) override;
+    QSharedPointer<RenderBackendResourceAccessor> resourceAccessor() const override;
+
+
     const GraphicsApiFilterData *contextInfo() const;
     SubmissionContext *submissionContext() const;
 
@@ -442,6 +451,7 @@ private:
 
     QVector<FrameGraphNode *> m_frameGraphLeaves;
     QScreen *m_screen = nullptr;
+    QSharedPointer<ResourceAccessor> m_scene2DResourceAccessor;
 };
 
 } // namespace Render
diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index 05ef4c130..15cba15d5 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -30,6 +30,7 @@
 #define TESTRENDERER_H
 
 #include <Qt3DRender/private/abstractrenderer_p.h>
+#include <Qt3DRender/private/resourceaccessor_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -42,10 +43,14 @@ public:
     void dumpInfo() const override {}
     API api() const override { return AbstractRenderer::OpenGL; }
     qint64 time() const override { return 0; }
-    void setTime(qint64 time) override { Q_UNUSED(time) }
-    void setNodeManagers(Qt3DRender::Render::NodeManagers *m) override { m_managers = m; }
-    void setServices(Qt3DCore::QServiceLocator *services) override { Q_UNUSED(services) }
-    void setSurfaceExposed(bool exposed) override { Q_UNUSED(exposed) }
+    void setTime(qint64 time) override { Q_UNUSED(time); }
+    void setNodeManagers(Qt3DRender::Render::NodeManagers *m) override
+    {
+        m_managers = m;
+        m_resourceAccessor.reset(new Qt3DRender::Render::ResourceAccessor(this, m_managers));
+    }
+    void setServices(Qt3DCore::QServiceLocator *services) override { Q_UNUSED(services); }
+    void setSurfaceExposed(bool exposed) override { Q_UNUSED(exposed); }
     Qt3DRender::Render::NodeManagers *nodeManagers() const override { return m_managers; }
     Qt3DCore::QServiceLocator *services() const override { return nullptr; }
     void initialize() override {}
@@ -86,12 +91,15 @@ public:
     QSurfaceFormat format() override;
 
     void setOpenGLContext(QOpenGLContext *) override {}
+    bool accessOpenGLTexture(Qt3DCore::QNodeId, QOpenGLTexture **, QMutex **, bool) override { return false; }
+    QSharedPointer<Qt3DRender::Render::RenderBackendResourceAccessor> resourceAccessor() const override { return m_resourceAccessor; }
 
     void loadShader(Qt3DRender::Render::Shader *, Qt3DRender::Render::HShader) override {}
 
 protected:
     Qt3DRender::Render::AbstractRenderer::BackendNodeDirtySet m_changes;
     Qt3DRender::Render::NodeManagers *m_managers = nullptr;
+    QSharedPointer<Qt3DRender::Render::ResourceAccessor> m_resourceAccessor;
 };
 
 QT_END_NAMESPACE