Merge branch 'wip/qtquickintegration' into dev

 Conflicts:
	src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
	src/render/backend/triangleboundingvolume.cpp
	src/render/backend/triangleboundingvolume_p.h
	src/render/frontend/qrenderaspect.cpp
	src/render/frontend/sphere.cpp
	src/render/frontend/sphere_p.h
	src/render/jobs/pickboundingvolumejob.cpp
	src/render/jobs/pickboundingvolumejob_p.h
	src/render/picking/objectpicker.cpp
	src/render/raycasting/qcollisionqueryresult_p.h
	src/render/render.pro
	src/src.pro
	tests/auto/render/objectpicker/tst_objectpicker.cpp
	tests/auto/render/render.pro

Change-Id: I95717c7855887850d5c90e7ad8f19f1ffb37a545

9 files changed, 1652 insertions, 2 deletions

diff --git a/src/quick3d/quick3drender/qt3dquickrender_logging.cpp b/src/quick3d/quick3drender/qt3dquickrender_logging.cpp
new file mode 100644
index 000000000..b9e5d2e08
--- /dev/null
+++ b/src/quick3d/quick3drender/qt3dquickrender_logging.cpp
@@ -0,0 +1,49 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt3dquickrender_logging_p.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender {
+namespace Quick {
+
+Q_LOGGING_CATEGORY(Scene2D, "Qt3D.Scene2D")
+
+} // Quick
+} // Qt3DRender
+
+QT_END_NAMESPACE
diff --git a/src/quick3d/quick3drender/qt3dquickrender_logging_p.h b/src/quick3d/quick3drender/qt3dquickrender_logging_p.h
new file mode 100644
index 000000000..c34abfdd3
--- /dev/null
+++ b/src/quick3d/quick3drender/qt3dquickrender_logging_p.h
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DQUICKRENDER_LOGGING_P_H
+#define QT3DQUICKRENDER_LOGGING_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QLoggingCategory>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender {
+namespace Quick {
+
+Q_DECLARE_LOGGING_CATEGORY(Scene2D)
+
+} // Quick
+} // Qt3DRender
+
+QT_END_NAMESPACE
+
+#endif // QT3DQUICKRENDER_LOGGING_P_H
diff --git a/src/quick3d/quick3drender/quick3drender.pro b/src/quick3d/quick3drender/quick3drender.pro
index 88d7a9556..b1b904e12 100644
--- a/src/quick3d/quick3drender/quick3drender.pro
+++ b/src/quick3d/quick3drender/quick3drender.pro
@@ -14,16 +14,19 @@ gcov {
 
 SOURCES += \
     qt3dquickrender_global.cpp \
-    qt3dquickrendernodefactory.cpp
+    qt3dquickrendernodefactory.cpp \
+    qt3dquickrender_logging.cpp
 
 HEADERS += \
     qt3dquickrendernodefactory_p.h \
     qt3dquickrender_global_p.h \
-    qt3dquickrender_global.h
+    qt3dquickrender_global.h \
+    qt3dquickrender_logging_p.h
 
 # otherwise mingw headers do not declare common functions like ::strcasecmp
 win32-g++*:QMAKE_CXXFLAGS_CXX11 = -std=gnu++0x
 
 include(./items/items.pri)
+include(./scene2d/scene2d.pri)
 
 load(qt_module)
diff --git a/src/quick3d/quick3drender/scene2d/qscene2d.cpp b/src/quick3d/quick3drender/scene2d/qscene2d.cpp
new file mode 100644
index 000000000..fa46cd3d2
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/qscene2d.cpp
@@ -0,0 +1,697 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qscene2d.h"
+#include "qscene2d_p.h"
+#include "scene2d_p.h"
+
+#include <Qt3DCore/QPropertyUpdatedChange>
+
+#include <QtGui/QOpenGLContext>
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt3DCore;
+
+namespace Qt3DRender {
+
+namespace Quick {
+
+/*!
+    \class Qt3DRender::QScene2D
+    \inmodule Qt3DRender
+
+    \brief This class enables rendering qml into a texture, which then can be
+    used as a part of 3D scene.
+
+    The component uses QQuickRenderControl to render the given QML source into an
+    offscreen surface, which is attached to a texture provided by the user. This allows the
+    component to directly render into the texture without intermediate copy and the user to
+    freely specify how the texture is used in the 3D scene.
+
+    \since 5.9
+*/
+
+/*!
+    \qmltype Scene2D
+    \inqmlmodule Qt3D.Render
+    \since
+    \ingroup
+    \instantiates Qt3DRender::QScene2D
+    \brief Scene2D
+ */
+
+/*!
+    \enum QScene2D::RenderPolicy
+
+    This enum type describes types of render policies available.
+    \value Continuous The Scene2D is rendering continuously. This is the default render policy.
+    \value SingleShot The Scene2D renders to the texture only once after which the resources
+                      allocated for rendering are released.
+*/
+
+/*!
+    \qmlproperty RenderTargetOutput Qt3D.Render::Scene2D::output
+    Holds the RenderTargetOutput, which specifies where the Scene2D is rendering to.
+ */
+
+/*!
+    \qmlproperty QUrl Qt3D.Render::Scene2D::source
+    Holds the qml source url.
+ */
+
+/*!
+    \qmlproperty enumeration Qt3D.Render::Scene2D::renderPolicy
+    Holds the render policy of this Scene2D.
+ */
+
+/*!
+    \qmlproperty bool Qt3D.Render::Scene2D::loaded
+    Holds whether the source has been loaded.
+ */
+
+class RenderControl : public QQuickRenderControl
+{
+public:
+    RenderControl(QWindow *w) : m_window(w) { }
+    QWindow *renderWindow(QPoint *offset) Q_DECL_OVERRIDE;
+
+private:
+    QWindow *m_window;
+};
+
+QWindow *RenderControl::renderWindow(QPoint *offset)
+{
+    if (offset)
+        *offset = QPoint(0, 0);
+    return m_window;
+}
+
+/*!
+    \internal
+     Constructs object shared by the front-end and back-end to synchronize the rendering.
+ */
+Scene2DSharedObject::Scene2DSharedObject(Scene2DManager *manager)
+    : m_quit(false)
+    , m_requestSync(false)
+    , m_prepared(false)
+    , m_initialized(false)
+    , m_renderControl(nullptr)
+    , m_quickWindow(nullptr)
+    , m_renderManager(manager)
+    , m_surface(nullptr)
+    , m_renderObject(nullptr)
+    , m_disallowed(false)
+{
+}
+
+Scene2DSharedObject::~Scene2DSharedObject()
+{
+}
+
+void Scene2DSharedObject::cleanup()
+{
+    delete m_renderControl;
+    delete m_quickWindow;
+    delete m_surface;
+    m_renderControl = nullptr;
+    m_quickWindow = nullptr;
+    m_surface = nullptr;
+    m_initialized = false;
+}
+
+bool Scene2DSharedObject::canRender() const
+{
+    return m_initialized && m_prepared && !m_disallowed;
+}
+
+bool Scene2DSharedObject::isInitialized() const
+{
+    return m_initialized;
+}
+
+void Scene2DSharedObject::disallowRender()
+{
+    m_disallowed = true;
+}
+
+void Scene2DSharedObject::setInitialized()
+{
+    m_initialized = true;
+}
+
+bool Scene2DSharedObject::isPrepared() const
+{
+    return m_prepared;
+}
+
+void Scene2DSharedObject::setPrepared()
+{
+    m_prepared = true;
+}
+
+// not protected, call only from main thread
+bool Scene2DSharedObject::isQuit() const
+{
+    Q_ASSERT(QThread::currentThread() == QCoreApplication::instance()->thread());
+    return m_quit;
+}
+
+// not protected, call only from main thread
+void Scene2DSharedObject::requestQuit()
+{
+    Q_ASSERT(QThread::currentThread() == QCoreApplication::instance()->thread());
+    m_quit = true;
+    QCoreApplication::postEvent(m_renderObject, new QEvent(QUIT));
+}
+
+bool Scene2DSharedObject::isSyncRequested() const
+{
+    return m_requestSync;
+}
+
+void Scene2DSharedObject::requestRender(bool sync)
+{
+    m_requestSync = sync;
+    QCoreApplication::postEvent(m_renderObject, new QEvent(RENDER));
+}
+
+void Scene2DSharedObject::wait()
+{
+    m_cond.wait(&m_mutex);
+}
+
+void Scene2DSharedObject::wake()
+{
+    m_cond.wakeOne();
+}
+
+void Scene2DSharedObject::clearSyncRequest()
+{
+    m_requestSync = false;
+}
+
+/*!
+    \internal
+     Constructs qml render manager.
+ */
+Scene2DManager::Scene2DManager(QScene2DPrivate *priv)
+    : m_priv(priv)
+    , m_qmlEngine(nullptr)
+    , m_qmlComponent(nullptr)
+    , m_rootItem(nullptr)
+    , m_source(nullptr)
+    , m_requested(false)
+    , m_initialized(false)
+    , m_renderSyncRequested(false)
+    , m_sharedObject(new Scene2DSharedObject(this))
+    , m_renderPolicy(QScene2D::Continuous)
+    , m_backendInitialized(false)
+    , m_noSourceMode(false)
+    , m_item(nullptr)
+    , m_ownEngine(false)
+{
+    m_sharedObject->m_surface = new QOffscreenSurface;
+    m_sharedObject->m_surface->setFormat(QSurfaceFormat::defaultFormat());
+    m_sharedObject->m_surface->create();
+
+    // Create render control
+    m_sharedObject->m_renderControl = new RenderControl(nullptr);
+
+    // Create window to render the QML with
+    m_sharedObject->m_quickWindow = new QQuickWindow(m_sharedObject->m_renderControl);
+    m_sharedObject->m_quickWindow->setClearBeforeRendering(false);
+
+    connect(m_sharedObject->m_renderControl, &QQuickRenderControl::renderRequested,
+            this, &Scene2DManager::requestRender);
+    connect(m_sharedObject->m_renderControl, &QQuickRenderControl::sceneChanged,
+            this, &Scene2DManager::requestRenderSync);
+}
+
+Scene2DManager::~Scene2DManager()
+{
+    m_sharedObject = nullptr;
+}
+
+void Scene2DManager::requestRender()
+{
+    // Don't request render until the backend is initialized.
+    if (m_sharedObject->canRender()) {
+        if (!m_requested) {
+            m_requested = true;
+            QCoreApplication::postEvent(this, new QEvent(RENDER));
+        }
+    }
+}
+
+void Scene2DManager::requestRenderSync()
+{
+    // Don't request render until the backed is initialized.
+    if (m_sharedObject->canRender()) {
+        if (!m_requested) {
+            m_requested = true;
+            QCoreApplication::postEvent(this, new QEvent(RENDERSYNC));
+        }
+    } else {
+        m_renderSyncRequested = true;
+    }
+}
+
+void Scene2DManager::startIfInitialized()
+{
+    if (!m_initialized && m_backendInitialized) {
+        if (m_source.isValid() && !m_noSourceMode) {
+            // Create a QML engine.
+            if (!m_qmlEngine) {
+                m_qmlEngine = new QQmlEngine;
+                if (!m_qmlEngine->incubationController()) {
+                    m_qmlEngine->setIncubationController(m_sharedObject->m_quickWindow
+                                                         ->incubationController());
+                }
+            }
+
+            // create component
+            m_ownEngine = true;
+            m_qmlComponent = new QQmlComponent(m_qmlEngine, m_source);
+            if (m_qmlComponent->isLoading()) {
+                connect(m_qmlComponent, &QQmlComponent::statusChanged,
+                        this, &Scene2DManager::run);
+            } else {
+                run();
+            }
+        } else if (m_item != nullptr) {
+            m_rootItem = m_item;
+
+            // Associate root item with the window.
+            m_rootItem->setParentItem(m_sharedObject->m_quickWindow->contentItem());
+
+            // Update window size.
+            updateSizes();
+
+            m_initialized = true;
+            m_sharedObject->setInitialized();
+        }
+    }
+}
+
+void Scene2DManager::stopAndClean()
+{
+    if (m_sharedObject->isInitialized()) {
+        QMutexLocker lock(&m_sharedObject->m_mutex);
+        m_sharedObject->requestQuit();
+        m_sharedObject->wait();
+        m_sharedObject->cleanup();
+        if (m_ownEngine) {
+            QObject::disconnect(m_connection);
+            delete m_qmlEngine;
+        }
+        delete m_qmlComponent;
+        m_qmlEngine = nullptr;
+        m_qmlComponent = nullptr;
+    }
+}
+
+void Scene2DManager::run()
+{
+    disconnect(m_qmlComponent, &QQmlComponent::statusChanged, this, &Scene2DManager::run);
+
+    if (m_qmlComponent->isError()) {
+        QList<QQmlError> errorList = m_qmlComponent->errors();
+        for (const QQmlError &error: errorList)
+            qWarning() << error.url() << error.line() << error;
+        return;
+    }
+
+    QObject *rootObject = m_qmlComponent->create();
+    if (m_qmlComponent->isError()) {
+        QList<QQmlError> errorList = m_qmlComponent->errors();
+        for (const QQmlError &error: errorList)
+            qWarning() << error.url() << error.line() << error;
+        return;
+    }
+
+    m_rootItem = qobject_cast<QQuickItem *>(rootObject);
+    if (!m_rootItem) {
+        qWarning("QScene2D: Root item is not a QQuickItem.");
+        delete rootObject;
+        return;
+    }
+
+    // The root item is ready. Associate it with the window.
+    m_rootItem->setParentItem(m_sharedObject->m_quickWindow->contentItem());
+
+    // Update window size.
+    updateSizes();
+
+    m_initialized = true;
+    m_sharedObject->setInitialized();
+
+    emit onLoadedChanged();
+}
+
+void Scene2DManager::updateSizes()
+{
+    const int width = m_rootItem->width();
+    const int height = m_rootItem->height();
+    if (width == 0 || height == 0) {
+        qWarning() << "QScene2D: Root item size not set.";
+        return;
+    }
+    m_sharedObject->m_quickWindow->setGeometry(0, 0, width, height);
+}
+
+void Scene2DManager::setSource(const QUrl &url)
+{
+    m_source = url;
+    startIfInitialized();
+}
+
+void Scene2DManager::setItem(QQuickItem *item)
+{
+    m_noSourceMode = true;
+    m_item = item;
+    startIfInitialized();
+}
+
+bool Scene2DManager::event(QEvent *e)
+{
+    switch (e->type()) {
+
+    case RENDER: {
+        // just render request, don't need to call sync in render thread
+        QMutexLocker lock(&m_sharedObject->m_mutex);
+        m_sharedObject->requestRender(false);
+        m_requested = false;
+        return true;
+    }
+
+    case RENDERSYNC: {
+        // sync and render request, main and render threads must be synchronized
+        if (!m_sharedObject->isQuit())
+            doRenderSync();
+        m_requested = false;
+        return true;
+    }
+
+    case PREPARE: {
+        m_sharedObject->m_renderControl->prepareThread(m_sharedObject->m_renderThread);
+        m_sharedObject->setPrepared();
+
+        if (m_renderSyncRequested) {
+            if (!m_requested) {
+                m_requested = true;
+                QCoreApplication::postEvent(this, new QEvent(RENDERSYNC));
+            }
+            m_renderSyncRequested = false;
+        }
+        return true;
+    }
+
+    case INITIALIZED: {
+        // backend is initialized, start the qml
+        m_backendInitialized = true;
+        startIfInitialized();
+        return true;
+    }
+
+    case RENDERED: {
+        // render is done, excellent, now clean anything not needed anymore.
+        stopAndClean();
+        return true;
+    }
+
+    default:
+        break;
+    }
+    return QObject::event(e);
+}
+
+bool Scene2DManager::forwardEvent(QEvent *event)
+{
+    switch (event->type()) {
+
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonDblClick:
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseButtonRelease: {
+        QMouseEvent* me = static_cast<QMouseEvent *>(event);
+        QPointF pos = me->localPos();
+        pos = QPointF(pos.x() * m_rootItem->width(), pos.y() * m_rootItem->height());
+        QMouseEvent nme = QMouseEvent(me->type(), pos, pos, pos, me->button(), me->buttons(),
+                                      me->modifiers(), Qt::MouseEventSynthesizedByApplication);
+        QCoreApplication::sendEvent(m_sharedObject->m_quickWindow, &nme);
+    } break;
+
+    case QEvent::KeyPress:
+    case QEvent::KeyRelease: {
+        QCoreApplication::sendEvent(m_sharedObject->m_quickWindow, event);
+    } break;
+
+    default:
+        break;
+    }
+    return false;
+}
+
+void Scene2DManager::doRenderSync()
+{
+    QMutexLocker lock(&m_sharedObject->m_mutex);
+
+    m_sharedObject->requestRender(true);
+    m_sharedObject->m_renderControl->polishItems();
+
+    // begin waiting render thread
+    m_sharedObject->wait();
+    m_requested = false;
+}
+
+void Scene2DManager::cleanup()
+{
+    stopAndClean();
+}
+
+void Scene2DManager::setEngine(QQmlEngine *engine)
+{
+    m_qmlEngine = engine;
+    m_ownEngine = false;
+    if (engine) {
+        m_connection = QObject::connect(engine, &QObject::destroyed,
+                                        this, &Scene2DManager::engineDestroyed);
+    }
+}
+
+void Scene2DManager::engineDestroyed()
+{
+    QObject::disconnect(m_connection);
+    m_qmlEngine = nullptr;
+    m_ownEngine = false;
+}
+
+
+QScene2DPrivate::QScene2DPrivate()
+    : Qt3DCore::QNodePrivate()
+    , m_renderManager(new Scene2DManager(this))
+    , m_output(nullptr)
+{
+}
+
+QScene2DPrivate::~QScene2DPrivate()
+{
+    m_renderManager->cleanup();
+    delete m_renderManager;
+}
+
+
+/*!
+    The constructor creates a new QScene2D instance with the specified \a parent.
+ */
+QScene2D::QScene2D(Qt3DCore::QNode *parent)
+    : Qt3DCore::QNode(*new QScene2DPrivate, parent)
+{
+    Q_D(QScene2D);
+    connect(d->m_renderManager, &Scene2DManager::onLoadedChanged,
+            this, &QScene2D::sourceLoaded);
+}
+
+QScene2D::QScene2D(QQmlEngine *engine, Qt3DCore::QNode *parent)
+    : Qt3DCore::QNode(*new QScene2DPrivate, parent)
+{
+    Q_D(QScene2D);
+    connect(d->m_renderManager, &Scene2DManager::onLoadedChanged,
+            this, &QScene2D::sourceLoaded);
+    d->m_renderManager->setEngine(engine);
+}
+
+QScene2D::~QScene2D()
+{
+}
+
+bool QScene2D::loaded() const
+{
+    Q_D(const QScene2D);
+    return d->m_renderManager->m_initialized;
+}
+
+/*!
+    \property QScene2D::source
+    \brief Specifies the url for the qml.
+
+    This property specifies the url to the qml being rendered to the texture.
+    The source must specify QQuickItem as a root. The item must specify width
+    and height. The rendered qml is scaled to the texture size.
+    The property can not be changed after the rendering has been initialized.
+ */
+QUrl QScene2D::source() const
+{
+    Q_D(const QScene2D);
+    return d->m_renderManager->m_source;
+}
+
+void QScene2D::setSource(const QUrl &url)
+{
+    Q_D(QScene2D);
+    if (d->m_renderManager->m_initialized) {
+        qWarning() << "Unable to set source after initialization.";
+        return;
+    }
+    if (d->m_renderManager->m_source != url) {
+        d->m_renderManager->setSource(url);
+        emit sourceChanged(url);
+    }
+}
+
+QQuickItem* QScene2D::item() const
+{
+    Q_D(const QScene2D);
+    return d->m_renderManager->m_item;
+}
+
+void QScene2D::setItem(QQuickItem *item)
+{
+    Q_D(QScene2D);
+    if (d->m_renderManager->m_initialized) {
+        qWarning() << "Unable to set item after initialization.";
+        return;
+    }
+    if (d->m_renderManager->m_item != item) {
+        d->m_renderManager->setItem(item);
+        emit itemChanged(item);
+    }
+}
+
+/*!
+    \property QScene2D::renderPolicy
+
+    Holds the render policy of this Scene2D.
+ */
+QScene2D::RenderPolicy QScene2D::renderPolicy() const
+{
+    Q_D(const QScene2D);
+    return d->m_renderManager->m_renderPolicy;
+}
+
+void QScene2D::setRenderPolicy(QScene2D::RenderPolicy renderPolicy)
+{
+    Q_D(const QScene2D);
+    if (d->m_renderManager->m_renderPolicy != renderPolicy) {
+        d->m_renderManager->m_renderPolicy = renderPolicy;
+        emit renderPolicyChanged(renderPolicy);
+    }
+}
+
+/*!
+    \property QScene2D::output
+    Holds the QRenderTargetOutput, which specifies where the QScene2D is
+    rendering to.
+ */
+Qt3DRender::QRenderTargetOutput *QScene2D::output() const
+{
+    Q_D(const QScene2D);
+    return d->m_output;
+}
+
+void QScene2D::setOutput(Qt3DRender::QRenderTargetOutput *output)
+{
+    Q_D(QScene2D);
+    if (d->m_output != output) {
+        if (d->m_output)
+            d->unregisterDestructionHelper(d->m_output);
+        d->m_output = output;
+        if (output)
+            d->registerDestructionHelper(output, &QScene2D::setOutput, d->m_output);
+        emit outputChanged(output);
+    }
+}
+
+Qt3DCore::QNodeCreatedChangeBasePtr QScene2D::createNodeCreationChange() const
+{
+    auto creationChange = Qt3DCore::QNodeCreatedChangePtr<QScene2DData>::create(this);
+    auto &data = creationChange->data;
+    Q_D(const QScene2D);
+    data.renderPolicy = d->m_renderManager->m_renderPolicy;
+    data.sharedObject = d->m_renderManager->m_sharedObject;
+    data.output = d->m_output ? d->m_output->id() : Qt3DCore::QNodeId();
+    return creationChange;
+}
+
+bool QScene2D::event(QEvent *event)
+{
+    Q_D(QScene2D);
+    d->m_renderManager->forwardEvent(event);
+    return true;
+}
+
+/*!
+    Returns the qml engine used by the QScene2D.
+ */
+QQmlEngine *QScene2D::engine() const
+{
+    Q_D(const QScene2D);
+    return d->m_renderManager->m_qmlEngine;
+}
+
+/*!
+    \internal
+ */
+void QScene2D::sourceLoaded()
+{
+    emit loadedChanged(true);
+}
+
+} // namespace Quick
+} // namespace Qt3DRender
+
+QT_END_NAMESPACE
diff --git a/src/quick3d/quick3drender/scene2d/qscene2d.h b/src/quick3d/quick3drender/scene2d/qscene2d.h
new file mode 100644
index 000000000..0a7e943d6
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/qscene2d.h
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QUICK3DRENDER_QSCENE2D_H
+#define QT3DRENDER_QUICK3DRENDER_QSCENE2D_H
+
+#include <Qt3DQuickRender/qt3dquickrender_global.h>
+#include <Qt3DRender/qrendertargetoutput.h>
+
+#include <QtCore/QUrl>
+#include <QtCore/QEvent>
+
+#include <Qt3DCore/qnode.h>
+
+#include <QtQuick/qquickitem.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender {
+
+namespace Quick {
+
+class QScene2DPrivate;
+
+class QT3DQUICKRENDERSHARED_EXPORT QScene2D : public Qt3DCore::QNode
+{
+    Q_OBJECT
+
+    Q_PROPERTY(Qt3DRender::QRenderTargetOutput *output READ output WRITE setOutput NOTIFY outputChanged)
+    Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
+    Q_PROPERTY(QScene2D::RenderPolicy renderPolicy READ renderPolicy WRITE setRenderPolicy NOTIFY renderPolicyChanged)
+    Q_PROPERTY(bool loaded READ loaded NOTIFY loadedChanged)
+    Q_PROPERTY(QQuickItem *item READ item WRITE setItem NOTIFY itemChanged)
+
+    Q_CLASSINFO("DefaultProperty", "item")
+
+public:
+
+    enum RenderPolicy {
+        Continuous,
+        SingleShot
+    };
+    Q_ENUM(RenderPolicy)
+
+    explicit QScene2D(Qt3DCore::QNode *parent = nullptr);
+    QScene2D(QQmlEngine *engine, Qt3DCore::QNode *parent = nullptr);
+    ~QScene2D();
+
+    Qt3DRender::QRenderTargetOutput *output() const;
+    QUrl source() const;
+    bool loaded() const;
+    QScene2D::RenderPolicy renderPolicy() const;
+    QQuickItem *item() const;
+    QQmlEngine *engine() const;
+    bool event(QEvent *event) Q_DECL_OVERRIDE;
+
+public Q_SLOTS:
+    void setOutput(Qt3DRender::QRenderTargetOutput *output);
+    void setSource(const QUrl &url);
+    void setRenderPolicy(QScene2D::RenderPolicy policy);
+    void setItem(QQuickItem *item);
+
+Q_SIGNALS:
+    void outputChanged(Qt3DRender::QRenderTargetOutput *output);
+    void sourceChanged(const QUrl &url);
+    void loadedChanged(bool loaded);
+    void renderPolicyChanged(QScene2D::RenderPolicy policy);
+    void itemChanged(QQuickItem *item);
+
+protected:
+    Q_DECLARE_PRIVATE(QScene2D)
+
+private:
+    Qt3DCore::QNodeCreatedChangeBasePtr createNodeCreationChange() const Q_DECL_OVERRIDE;
+
+    void sourceLoaded();
+};
+
+} // namespace Quick
+} // namespace Qt3DRender
+
+QT_END_NAMESPACE
+
+#endif // QT3DRENDER_QUICK3DRENDER_QSCENE2D_H
diff --git a/src/quick3d/quick3drender/scene2d/qscene2d_p.h b/src/quick3d/quick3drender/scene2d/qscene2d_p.h
new file mode 100644
index 000000000..34b54b231
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/qscene2d_p.h
@@ -0,0 +1,219 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_QUICK3DRENDER_QSCENE2D_P_H
+#define QT3DRENDER_QUICK3DRENDER_QSCENE2D_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlComponent>
+#include <QtQuick/QQuickItem>
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/QQuickRenderControl>
+#include <QtGui/QOffscreenSurface>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QWaitCondition>
+#include <QtCore/QThread>
+
+#include <Qt3DQuickRender/qscene2d.h>
+#include <Qt3DRender/qabstracttexture.h>
+
+#include <private/qobject_p.h>
+#include <private/qnode_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender {
+
+namespace Quick {
+
+class QScene2D;
+class Scene2DManager;
+
+// render thread -> render thread
+static const QEvent::Type INITIALIZE = QEvent::Type(QEvent::User + 1);
+
+// main thread -> main thread, render thread
+static const QEvent::Type RENDER = QEvent::Type(QEvent::User + 2);
+
+// main thread -> main thread
+static const QEvent::Type RENDERSYNC = QEvent::Type(QEvent::User + 3);
+
+// render thread -> main thread
+static const QEvent::Type PREPARE = QEvent::Type(QEvent::User + 4);
+static const QEvent::Type INITIALIZED = QEvent::Type(QEvent::User + 5);
+static const QEvent::Type RENDERED = QEvent::Type(QEvent::User + 6);
+
+// main thread -> render thread
+static const QEvent::Type QUIT = QEvent::Type(QEvent::User + 7);
+
+class Q_AUTOTEST_EXPORT Scene2DSharedObject
+{
+public:
+    Scene2DSharedObject(Scene2DManager *manager);
+    ~Scene2DSharedObject();
+
+    QQuickRenderControl *m_renderControl;
+    QQuickWindow *m_quickWindow;
+    Scene2DManager *m_renderManager;
+    QOffscreenSurface *m_surface;
+
+    QThread *m_renderThread;
+    QObject *m_renderObject;
+
+    QWaitCondition m_cond;
+    QMutex m_mutex;
+
+    bool isInitialized() const;
+    void setInitialized();
+
+    void requestQuit();
+    bool isQuit() const;
+
+    void requestRender(bool sync);
+
+    bool isSyncRequested() const;
+    void clearSyncRequest();
+
+    void wait();
+    void wake();
+
+    bool isPrepared() const;
+    void setPrepared();
+
+    void disallowRender();
+    bool canRender() const;
+
+    void cleanup();
+
+private:
+
+    bool m_disallowed;
+    bool m_quit;
+    bool m_requestSync;
+    bool m_requestRender;
+    bool m_prepared;
+    bool m_initialized;
+};
+
+typedef QSharedPointer<Scene2DSharedObject> Scene2DSharedObjectPtr;
+
+class Q_AUTOTEST_EXPORT QScene2DPrivate : public Qt3DCore::QNodePrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QScene2D)
+
+    QScene2DPrivate();
+    ~QScene2DPrivate();
+
+    Scene2DManager *m_renderManager;
+    QMetaObject::Connection m_textureDestroyedConnection;
+    Qt3DRender::QRenderTargetOutput *m_output;
+};
+
+struct QScene2DData
+{
+    QScene2D::RenderPolicy renderPolicy;
+    Scene2DSharedObjectPtr sharedObject;
+    Qt3DCore::QNodeId output;
+};
+
+class Scene2DManager : public QObject
+{
+    Q_OBJECT
+public:
+    Scene2DManager(QScene2DPrivate *priv);
+    ~Scene2DManager();
+
+    QQmlEngine *m_qmlEngine;
+    QQmlComponent *m_qmlComponent;
+    QQuickItem *m_rootItem;
+    QQuickItem *m_item;
+
+    QScene2DPrivate *m_priv;
+    QSharedPointer<Scene2DSharedObject> m_sharedObject;
+
+    QUrl m_source;
+    Qt3DCore::QNodeId m_id;
+    QMetaObject::Connection m_connection;
+    QScene2D::RenderPolicy m_renderPolicy;
+
+    bool m_requested;
+    bool m_initialized;
+    bool m_renderSyncRequested;
+    bool m_backendInitialized;
+    bool m_noSourceMode;
+    bool m_ownEngine;
+
+    void requestRender();
+    void requestRenderSync();
+    void doRenderSync();
+    void startIfInitialized();
+    void stopAndClean();
+    void run();
+    void updateSizes();
+
+    void setSource(const QUrl &url);
+    void setItem(QQuickItem *item);
+
+    bool event(QEvent *e) Q_DECL_OVERRIDE;
+    bool forwardEvent(QEvent *event);
+
+    Q_SIGNAL void onLoadedChanged();
+
+    void cleanup();
+    void setEngine(QQmlEngine *engine);
+    void engineDestroyed();
+};
+
+} // namespace Quick
+} // namespace Qt3DRender
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(Qt3DRender::Quick::Scene2DSharedObjectPtr)
+
+#endif // QT3DRENDER_QUICK3DRENDER_QSCENE2D_P_H
diff --git a/src/quick3d/quick3drender/scene2d/scene2d.cpp b/src/quick3d/quick3drender/scene2d/scene2d.cpp
new file mode 100644
index 000000000..227829f3e
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/scene2d.cpp
@@ -0,0 +1,363 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <Qt3DCore/qpropertyupdatedchange.h>
+#include <Qt3DQuickRender/qscene2d.h>
+
+#include <QtCore/qthread.h>
+#include <QtCore/qatomic.h>
+
+#include <private/qscene2d_p.h>
+#include <private/scene2d_p.h>
+#include <private/graphicscontext_p.h>
+#include <private/texture_p.h>
+#include <private/nodemanagers_p.h>
+#include <private/resourceaccessor_p.h>
+#include <private/attachmentpack_p.h>
+#include <private/qt3dquickrender_logging_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef GL_DEPTH24_STENCIL8
+#define GL_DEPTH24_STENCIL8 0x88F0
+#endif
+
+using namespace Qt3DRender::Quick;
+
+namespace Qt3DRender {
+
+namespace Render {
+
+namespace Quick {
+
+Q_GLOBAL_STATIC(QThread, renderThread)
+Q_GLOBAL_STATIC(QAtomicInt, renderThreadClientCount)
+
+#ifndef GL_DEPTH24_STENCIL8
+#define GL_DEPTH24_STENCIL8 0x88F0
+#endif
+
+RenderQmlEventHandler::RenderQmlEventHandler(Scene2D *node)
+    : QObject()
+    , m_node(node)
+{
+}
+
+// Event handler for the RenderQmlToTexture::renderThread
+bool RenderQmlEventHandler::event(QEvent *e)
+{
+    switch (e->type()) {
+
+    case RENDER: {
+        m_node->render();
+        return true;
+    }
+
+    case INITIALIZE: {
+        m_node->initializeRender();
+        return true;
+    }
+
+    case QUIT: {
+        m_node->cleanup();
+        return true;
+    }
+
+    default:
+        break;
+    }
+    return QObject::event(e);
+}
+
+Scene2D::Scene2D()
+    : m_context(nullptr)
+    , m_shareContext(nullptr)
+    , m_sharedObject(nullptr)
+    , m_renderThread(nullptr)
+    , m_initialized(false)
+    , m_renderInitialized(false)
+    , m_renderPolicy(Qt3DRender::Quick::QScene2D::Continuous)
+    , m_fbo(0)
+    , m_rbo(0)
+{
+    renderThreadClientCount->fetchAndAddAcquire(1);
+}
+
+Scene2D::~Scene2D()
+{
+    // this gets called from aspect thread. Wait for the render thread then delete it.
+    // TODO: render thread deletion
+//     if (m_renderThread) {
+//        m_renderThread->wait(1000);
+//        delete m_renderThread;
+//    }
+}
+
+void Scene2D::setOutput(Qt3DCore::QNodeId outputId)
+{
+    m_outputId = outputId;
+}
+
+void Scene2D::initializeSharedObject()
+{
+    if (!m_initialized) {
+
+        renderThread->setObjectName(QStringLiteral("Scene2D::renderThread"));
+        m_renderThread = renderThread;
+        m_sharedObject->m_renderThread = m_renderThread;
+
+        // Create event handler for the render thread
+        m_sharedObject->m_renderObject = new RenderQmlEventHandler(this);
+        m_sharedObject->m_renderObject->moveToThread(m_sharedObject->m_renderThread);
+        if (!m_sharedObject->m_renderThread->isRunning())
+            m_sharedObject->m_renderThread->start();
+
+        // Notify main thread we have been initialized
+        if (m_sharedObject->m_renderManager)
+            QCoreApplication::postEvent(m_sharedObject->m_renderManager, new QEvent(INITIALIZED));
+
+        // Initialize render thread
+        QCoreApplication::postEvent(m_sharedObject->m_renderObject, new QEvent(INITIALIZE));
+
+        m_initialized = true;
+    }
+}
+
+void Scene2D::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+{
+    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QScene2DData>>(change);
+    const auto &data = typedChange->data;
+    m_renderPolicy = data.renderPolicy;
+    setSharedObject(data.sharedObject);
+    setOutput(data.output);
+    m_shareContext = renderer()->shareContext();
+}
+
+void Scene2D::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+{
+    if (e->type() == Qt3DCore::PropertyUpdated) {
+        Qt3DCore::QPropertyUpdatedChangePtr propertyChange
+                = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
+        if (propertyChange->propertyName() == QByteArrayLiteral("renderPolicy")) {
+            m_renderPolicy = propertyChange->value().value<QScene2D::RenderPolicy>();
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("output")) {
+            Qt3DCore::QNodeId outputId = propertyChange->value().value<Qt3DCore::QNodeId>();
+            setOutput(outputId);
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("sharedObject")) {
+            const Scene2DSharedObjectPtr sharedObject
+                    = propertyChange->value().value<Scene2DSharedObjectPtr>();
+            setSharedObject(sharedObject);
+        }
+    }
+    BackendNode::sceneChangeEvent(e);
+}
+
+void Scene2D::setSharedObject(Qt3DRender::Quick::Scene2DSharedObjectPtr sharedObject)
+{
+    m_sharedObject = sharedObject;
+    if (!m_initialized)
+        initializeSharedObject();
+}
+
+void Scene2D::initializeRender()
+{
+    if (!m_renderInitialized && m_sharedObject.data() != nullptr) {
+
+        QSurfaceFormat format;
+        format.setDepthBufferSize(24);
+        format.setStencilBufferSize(8);
+
+        m_context = new QOpenGLContext();
+        m_context->setFormat(format);
+        m_context->setShareContext(m_shareContext);
+        m_context->create();
+
+        m_context->makeCurrent(m_sharedObject->m_surface);
+        m_sharedObject->m_renderControl->initialize(m_context);
+        m_context->doneCurrent();
+
+        QCoreApplication::postEvent(m_sharedObject->m_renderManager, new QEvent(PREPARE));
+        m_renderInitialized = true;
+    }
+}
+
+bool Scene2D::updateFbo(QOpenGLTexture *texture)
+{
+    QOpenGLFunctions *gl = m_context->functions();
+    if (m_fbo == 0) {
+        gl->glGenFramebuffers(1, &m_fbo);
+        gl->glGenRenderbuffers(1, &m_rbo);
+    }
+    // TODO: Add another codepath when GL_DEPTH24_STENCIL8 is not supported
+    gl->glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
+    gl->glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8,
+                              m_textureSize.width(), m_textureSize.height());
+    gl->glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+    gl->glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+    gl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                               GL_TEXTURE_2D, texture->textureId(), 0);
+    gl->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbo);
+    GLenum status = gl->glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    gl->glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    if (status != GL_FRAMEBUFFER_COMPLETE)
+        return false;
+    return true;
+}
+
+void Scene2D::syncRenderControl()
+{
+    if (m_sharedObject->isSyncRequested()) {
+
+        m_sharedObject->clearSyncRequest();
+
+        m_sharedObject->m_renderControl->sync();
+
+        // gui thread can now continue
+        m_sharedObject->wake();
+    }
+}
+
+void Scene2D::render()
+{
+    if (m_initialized && m_renderInitialized && m_sharedObject.data() != nullptr) {
+
+        QMutexLocker lock(&m_sharedObject->m_mutex);
+
+        QOpenGLTexture *texture = nullptr;
+        const Qt3DRender::Render::Attachment *attachmentData = nullptr;
+        QMutex *textureLock = nullptr;
+
+        m_context->makeCurrent(m_sharedObject->m_surface);
+
+        if (resourceAccessor()->accessResource(m_outputId, (void**)&attachmentData, nullptr)) {
+            if (!resourceAccessor()->accessResource(attachmentData->m_textureUuid,
+                                                       (void**)&texture, &textureLock)) {
+                // Need to call sync even if the texture is not in use
+                syncRenderControl();
+                m_context->doneCurrent();
+                qCWarning(Qt3DRender::Quick::Scene2D) << Q_FUNC_INFO << "Texture not in use.";
+                QCoreApplication::postEvent(m_sharedObject->m_renderObject, new QEvent(RENDER));
+                return;
+            }
+            textureLock->lock();
+            const QSize textureSize = QSize(texture->width(), texture->height());
+            if (m_attachmentData.m_textureUuid != attachmentData->m_textureUuid
+                || m_attachmentData.m_point != attachmentData->m_point
+                || m_attachmentData.m_face != attachmentData->m_face
+                || m_attachmentData.m_layer != attachmentData->m_layer
+                || m_attachmentData.m_mipLevel != attachmentData->m_mipLevel
+                || m_textureSize != textureSize) {
+                m_textureSize = textureSize;
+                m_attachmentData = *attachmentData;
+                if (!updateFbo(texture)) {
+                    // Need to call sync even if the fbo is not usable
+                    syncRenderControl();
+                    textureLock->unlock();
+                    m_context->doneCurrent();
+                    qCWarning(Qt3DRender::Quick::Scene2D) << Q_FUNC_INFO << "Fbo not initialized.";
+                    return;
+                }
+            }
+        }
+
+        if (m_fbo != m_sharedObject->m_quickWindow->renderTargetId())
+            m_sharedObject->m_quickWindow->setRenderTarget(m_fbo, m_textureSize);
+
+        // Call disallow rendering while mutex is locked
+        if (m_renderPolicy == QScene2D::SingleShot)
+            m_sharedObject->disallowRender();
+
+        // Sync
+        if (m_sharedObject->isSyncRequested()) {
+
+            m_sharedObject->clearSyncRequest();
+
+            m_sharedObject->m_renderControl->sync();
+        }
+
+        // Render
+        m_sharedObject->m_renderControl->render();
+
+        // Tell main thread we are done so it can begin cleanup if this is final frame
+        if (m_renderPolicy == QScene2D::SingleShot)
+            QCoreApplication::postEvent(m_sharedObject->m_renderManager, new QEvent(RENDERED));
+
+        m_sharedObject->m_quickWindow->resetOpenGLState();
+        m_context->functions()->glFlush();
+        if (texture->isAutoMipMapGenerationEnabled())
+            texture->generateMipMaps();
+        textureLock->unlock();
+        m_context->doneCurrent();
+
+        // gui thread can now continue
+        m_sharedObject->wake();
+    }
+}
+
+// this function gets called while the main thread is waiting
+void Scene2D::cleanup()
+{
+    if (m_renderInitialized && m_initialized) {
+        m_context->makeCurrent(m_sharedObject->m_surface);
+        m_sharedObject->m_renderControl->invalidate();
+        m_context->functions()->glDeleteFramebuffers(1, &m_fbo);
+        m_context->functions()->glDeleteRenderbuffers(1, &m_rbo);
+        m_context->doneCurrent();
+        m_renderInitialized = false;
+    }
+    if (m_initialized) {
+        delete m_sharedObject->m_renderObject;
+        m_sharedObject->m_renderObject = nullptr;
+        delete m_context;
+        m_context = nullptr;
+        m_initialized = false;
+    }
+    // wake up the main thread
+    m_sharedObject->wake();
+    m_sharedObject = nullptr;
+
+    renderThreadClientCount->fetchAndSubAcquire(1);
+    if (renderThreadClientCount->load() == 0)
+        renderThread->quit();
+}
+
+} // namespace Quick
+} // namespace Render
+} // namespace Qt3DRender
+
+QT_END_NAMESPACE
diff --git a/src/quick3d/quick3drender/scene2d/scene2d.pri b/src/quick3d/quick3drender/scene2d/scene2d.pri
new file mode 100644
index 000000000..4635c43e1
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/scene2d.pri
@@ -0,0 +1,10 @@
+HEADERS += \
+    $$PWD/qscene2d.h \
+    $$PWD/qscene2d_p.h \
+    $$PWD/scene2d_p.h
+
+SOURCES += \
+    $$PWD/qscene2d.cpp \
+    $$PWD/scene2d.cpp
+
+INCLUDEPATH += $$PWD
diff --git a/src/quick3d/quick3drender/scene2d/scene2d_p.h b/src/quick3d/quick3drender/scene2d/scene2d_p.h
new file mode 100644
index 000000000..3a8ccf531
--- /dev/null
+++ b/src/quick3d/quick3drender/scene2d/scene2d_p.h
@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT3DRENDER_RENDER_QUICK_SCENE2D_P_H
+#define QT3DRENDER_RENDER_QUICK_SCENE2D_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <Qt3DCore/qnodeid.h>
+#include <Qt3DQuickRender/qscene2d.h>
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QSemaphore>
+
+#include <private/qscene2d_p.h>
+#include <private/qrendertargetoutput_p.h>
+#include <private/backendnode_p.h>
+#include <private/attachmentpack_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Qt3DRender {
+
+namespace Render {
+
+class GraphicsContext;
+
+namespace Quick {
+
+class Scene2D;
+
+class RenderQmlEventHandler : public QObject
+{
+    Q_OBJECT
+public:
+    RenderQmlEventHandler(Scene2D *node);
+    bool event(QEvent *e) Q_DECL_OVERRIDE;
+
+private:
+    Scene2D *m_node;
+};
+
+class QT3DQUICKRENDERSHARED_EXPORT Scene2D : public Qt3DRender::Render::BackendNode
+{
+public:
+    Scene2D();
+    ~Scene2D();
+
+    void render();
+    void initializeRender();
+    void setSharedObject(Qt3DRender::Quick::Scene2DSharedObjectPtr sharedObject);
+    void cleanup();
+    void setOutput(Qt3DCore::QNodeId outputId);
+    void initializeSharedObject();
+
+    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) Q_DECL_OVERRIDE;
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE;
+
+    bool updateFbo(QOpenGLTexture *texture);
+    void syncRenderControl();
+
+    QOpenGLContext *m_context;
+    QOpenGLContext *m_shareContext;
+    QThread *m_renderThread;
+    Qt3DCore::QNodeId m_outputId;
+    QSharedPointer<Qt3DRender::Quick::Scene2DSharedObject> m_sharedObject;
+    Qt3DCore::QNodeId m_peerId;
+    Qt3DRender::Render::Attachment m_attachmentData;
+
+    GLuint m_fbo;
+    GLuint m_rbo;
+    QSize m_textureSize;
+
+    bool m_initialized;
+    bool m_renderInitialized;
+    Qt3DRender::Quick::QScene2D::RenderPolicy m_renderPolicy;
+};
+
+} // Quick
+} // Render
+} // Qt3DRender
+
+QT_END_NAMESPACE
+
+#endif // QT3DRENDER_RENDER_QUICK_SCENE2D_P_H