[qt] Render asynchronously

platform/qt/qt.cmake

@@ -61,8 +61,12 @@ add_library(qmapboxgl SHARED
     platform/qt/src/qmapbox.cpp
     platform/qt/src/qmapboxgl.cpp
     platform/qt/src/qmapboxgl_p.hpp
-    platform/qt/src/qmapboxgl_renderer_frontend_p.hpp
-    platform/qt/src/qmapboxgl_renderer_frontend_p.cpp
+    platform/qt/src/qmapboxgl_map_observer.cpp
+    platform/qt/src/qmapboxgl_map_observer.hpp
+    platform/qt/src/qmapboxgl_map_renderer.cpp
+    platform/qt/src/qmapboxgl_map_renderer.hpp
+    platform/qt/src/qmapboxgl_renderer_backend.hpp
+    platform/qt/src/qmapboxgl_renderer_backend.cpp
     platform/default/mbgl/util/default_styles.hpp
 )
 

platform/qt/src/qmapboxgl.cpp

@@ -1,6 +1,7 @@
 #include "qmapboxgl.hpp"
 #include "qmapboxgl_p.hpp"
-#include "qmapboxgl_renderer_frontend_p.hpp"
+
+#include "qmapboxgl_map_observer.hpp"
 
 #include "qt_conversion.hpp"
 #include "qt_geojson.hpp"
@@ -43,11 +44,8 @@
 
 #if QT_VERSION >= 0x050000
 #include <QGuiApplication>
-#include <QWindow>
-#include <QOpenGLContext>
 #else
 #include <QCoreApplication>
-#include <QGLContext>
 #endif
 
 #include <QDebug>
@@ -1058,22 +1056,24 @@ void QMapboxGL::rotateBy(const QPointF &first, const QPointF &second)
         map->resize(size / 2, size);
     \endcode
 */
-void QMapboxGL::resize(const QSize& size, const QSize& framebufferSize)
+void QMapboxGL::resize(const QSize& size_, const QSize& framebufferSize)
 {
-    if (d_ptr->size == size && d_ptr->fbSize == framebufferSize) return;
+    auto size = sanitizedSize(size_);
 
-    d_ptr->size = size;
-    d_ptr->fbSize = framebufferSize;
+    if (d_ptr->mapObj->getSize() == size)
+        return;
 
-    d_ptr->mapObj->setSize(sanitizedSize(size));
+    d_ptr->mapRenderer->updateFramebufferSize(sanitizedSize(framebufferSize));
+    d_ptr->mapObj->setSize(size);
 }
 
 /*!
     If Mapbox GL needs to rebind the default \a fbo, it will use the
     ID supplied here.
 */
-void QMapboxGL::setFramebufferObject(quint32 fbo) {
-    d_ptr->fbObject = fbo;
+void QMapboxGL::setFramebufferObject(quint32)
+{
+    // FIXME: No-op, implicit.
 }
 
 /*!
@@ -1486,8 +1486,7 @@ void QMapboxGL::render()
     }
 #endif
 
-    d_ptr->dirty = false;
-    d_ptr->render();
+    d_ptr->mapRenderer->render();
 }
 
 /*!
@@ -1496,7 +1495,7 @@ void QMapboxGL::render()
 */
 void QMapboxGL::connectionEstablished()
 {
-    d_ptr->connectionEstablished();
+    mbgl::NetworkStatus::Reachable();
 }
 
 /*!
@@ -1526,11 +1525,8 @@ void QMapboxGL::connectionEstablished()
     \a copyrightsHtml is a string with a HTML snippet.
 */
 
-class QMapboxGLRendererFrontend;
-
-QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settings, const QSize &size_, qreal pixelRatio)
+QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settings, const QSize &size, qreal pixelRatio)
     : QObject(q)
-    , size(size_)
     , q_ptr(q)
     , fileSourceObj(sharedDefaultFileSource(
         settings.cacheDatabasePath().toStdString(),
@@ -1538,174 +1534,48 @@ QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settin
         settings.cacheDatabaseMaximumSize()))
     , threadPool(mbgl::sharedThreadPool())
 {
-    // Setup resource transform if needed
+    // Setup the FileSource
+    fileSourceObj->setAccessToken(settings.accessToken().toStdString());
+    fileSourceObj->setAPIBaseURL(settings.apiBaseUrl().toStdString());
+
     if (settings.resourceTransform()) {
-      m_resourceTransform =
-        std::make_unique< mbgl::Actor<mbgl::ResourceTransform> >( *mbgl::Scheduler::GetCurrent(),
-                                                                  [callback = settings.resourceTransform()]
-                                                                  (mbgl::Resource::Kind , const std::string&& url_)  -> std::string {
-                                                                    return callback(std::move(url_));
-                                                                  }
-                                                                  );
-      fileSourceObj->setResourceTransform(m_resourceTransform->self());
+        m_resourceTransform = std::make_unique<mbgl::Actor<mbgl::ResourceTransform>>(*mbgl::Scheduler::GetCurrent(),
+            [callback = settings.resourceTransform()] (mbgl::Resource::Kind, const std::string &&url_) -> std::string {
+                return callback(std::move(url_));
+            });
+       fileSourceObj->setResourceTransform(m_resourceTransform->self());
     }
 
-    // Setup and connect the renderer frontend
-    frontend = std::make_unique<QMapboxGLRendererFrontend>(
-            std::make_unique<mbgl::Renderer>(*this, pixelRatio, *fileSourceObj, *threadPool,
-                                             static_cast<mbgl::GLContextMode>(settings.contextMode())),
-            *this);
-    connect(frontend.get(), SIGNAL(updated()), this, SLOT(invalidate()));
+    // Setup MapObserver
+    mapObserver = std::make_unique<QMapboxGLMapObserver>(this);
 
+    qRegisterMetaType<QMapboxGL::MapChange>("QMapboxGL::MapChange");
+
+    connect(mapObserver.get(), SIGNAL(mapChanged(QMapboxGL::MapChange)), q_ptr, SIGNAL(mapChanged(QMapboxGL::MapChange)));
+    connect(mapObserver.get(), SIGNAL(copyrightsChanged(QString)), q_ptr, SIGNAL(copyrightsChanged(QString)));
+
+    // Setup RendererBackend
+    mapRenderer = std::make_unique<QMapboxGLMapRenderer>(pixelRatio, *fileSourceObj, *threadPool, settings.contextMode());
+
+    // Setup the Map object
     mapObj = std::make_unique<mbgl::Map>(
-            *frontend,
-            *this, sanitizedSize(size),
+            *this, // RendererFrontend
+            *mapObserver,
+            sanitizedSize(size),
             pixelRatio, *fileSourceObj, *threadPool,
             mbgl::MapMode::Continuous,
             static_cast<mbgl::ConstrainMode>(settings.constrainMode()),
             static_cast<mbgl::ViewportMode>(settings.viewportMode()));
 
-    qRegisterMetaType<QMapboxGL::MapChange>("QMapboxGL::MapChange");
-
-    fileSourceObj->setAccessToken(settings.accessToken().toStdString());
-    fileSourceObj->setAPIBaseURL(settings.apiBaseUrl().toStdString());
-
-    connect(this, SIGNAL(needsRendering()), q_ptr, SIGNAL(needsRendering()), Qt::QueuedConnection);
-    connect(this, SIGNAL(mapChanged(QMapboxGL::MapChange)), q_ptr, SIGNAL(mapChanged(QMapboxGL::MapChange)), Qt::QueuedConnection);
-    connect(this, SIGNAL(copyrightsChanged(QString)), q_ptr, SIGNAL(copyrightsChanged(QString)), Qt::QueuedConnection);
+    connect(this, SIGNAL(needsRendering()), q_ptr, SIGNAL(needsRendering()));
 }
 
 QMapboxGLPrivate::~QMapboxGLPrivate()
 {
 }
 
-mbgl::Size QMapboxGLPrivate::getFramebufferSize() const {
-    return sanitizedSize(fbSize);
-}
-
-void QMapboxGLPrivate::updateAssumedState() {
-    assumeFramebufferBinding(fbObject);
-#if QT_VERSION >= 0x050600
-    assumeViewport(0, 0, getFramebufferSize());
-#endif
-}
-
-void QMapboxGLPrivate::bind() {
-    setFramebufferBinding(fbObject);
-    setViewport(0, 0, getFramebufferSize());
-}
-
-void QMapboxGLPrivate::invalidate()
+void QMapboxGLPrivate::update(std::shared_ptr<mbgl::UpdateParameters> parameters)
 {
-    if (!dirty) {
-        emit needsRendering();
-        dirty = true;
-    }
-}
-
-void QMapboxGLPrivate::render()
-{
-    frontend->render();
-}
-
-void QMapboxGLPrivate::onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode)
-{
-    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
-        emit mapChanged(QMapboxGL::MapChangeRegionWillChange);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeRegionWillChangeAnimated);
-    }
-}
-
-void QMapboxGLPrivate::onCameraIsChanging()
-{
-    emit mapChanged(QMapboxGL::MapChangeRegionIsChanging);
-}
-
-void QMapboxGLPrivate::onCameraDidChange(mbgl::MapObserver::CameraChangeMode mode)
-{
-    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
-        emit mapChanged(QMapboxGL::MapChangeRegionDidChange);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeRegionDidChangeAnimated);
-    }
-}
-
-void QMapboxGLPrivate::onWillStartLoadingMap()
-{
-    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
-}
-
-void QMapboxGLPrivate::onDidFinishLoadingMap()
-{
-    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingMap);
-}
-
-void QMapboxGLPrivate::onDidFailLoadingMap(std::exception_ptr)
-{
-    emit mapChanged(QMapboxGL::MapChangeDidFailLoadingMap);
-}
-
-void QMapboxGLPrivate::onWillStartRenderingFrame()
-{
-    emit mapChanged(QMapboxGL::MapChangeWillStartRenderingFrame);
-}
-
-void QMapboxGLPrivate::onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode mode)
-{
-    if (mode == mbgl::MapObserver::RenderMode::Partial) {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrame);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrameFullyRendered);
-    }
-}
-
-void QMapboxGLPrivate::onWillStartRenderingMap()
-{
-    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
-}
-
-void QMapboxGLPrivate::onDidFinishRenderingMap(mbgl::MapObserver::RenderMode mode)
-{
-    if (mode == mbgl::MapObserver::RenderMode::Partial) {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMap);
-    } else {
-        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMapFullyRendered);
-    }
-}
-
-void QMapboxGLPrivate::onDidFinishLoadingStyle()
-{
-    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingStyle);
-}
-
-void QMapboxGLPrivate::onSourceChanged(mbgl::style::Source&)
-{
-    std::string attribution;
-    for (const auto& source : mapObj->getStyle().getSources()) {
-        // Avoid duplicates by using the most complete attribution HTML snippet.
-        if (source->getAttribution() && (attribution.size() < source->getAttribution()->size()))
-            attribution = *source->getAttribution();
-    }
-    emit copyrightsChanged(QString::fromStdString(attribution));
-    emit mapChanged(QMapboxGL::MapChangeSourceDidChange);
-}
-
-/*!
-    Initializes an OpenGL extension function such as Vertex Array Objects (VAOs),
-    required by Mapbox GL Native engine.
-*/
-mbgl::gl::ProcAddress QMapboxGLPrivate::getExtensionFunctionPointer(const char* name) {
-#if QT_VERSION >= 0x050000
-    QOpenGLContext* thisContext = QOpenGLContext::currentContext();
-    return thisContext->getProcAddress(name);
-#else
-    const QGLContext* thisContext = QGLContext::currentContext();
-    return reinterpret_cast<mbgl::gl::ProcAddress>(thisContext->getProcAddress(name));
-#endif
-}
-
-void QMapboxGLPrivate::connectionEstablished()
-{
-    mbgl::NetworkStatus::Reachable();
+    mapRenderer->updateParameters(std::move(parameters));
+    emit needsRendering();
 }

platform/qt/src/qmapboxgl_map_observer.cpp

@@ -0,0 +1,95 @@
+#include "qmapboxgl_map_observer.hpp"
+
+#include "qmapboxgl_p.hpp"
+
+QMapboxGLMapObserver::QMapboxGLMapObserver(QMapboxGLPrivate *d)
+    : d_ptr(d)
+{
+}
+
+QMapboxGLMapObserver::~QMapboxGLMapObserver()
+{
+}
+
+void QMapboxGLMapObserver::onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode)
+{
+    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
+        emit mapChanged(QMapboxGL::MapChangeRegionWillChange);
+    } else {
+        emit mapChanged(QMapboxGL::MapChangeRegionWillChangeAnimated);
+    }
+}
+
+void QMapboxGLMapObserver::onCameraIsChanging()
+{
+    emit mapChanged(QMapboxGL::MapChangeRegionIsChanging);
+}
+
+void QMapboxGLMapObserver::onCameraDidChange(mbgl::MapObserver::CameraChangeMode mode)
+{
+    if (mode == mbgl::MapObserver::CameraChangeMode::Immediate) {
+        emit mapChanged(QMapboxGL::MapChangeRegionDidChange);
+    } else {
+        emit mapChanged(QMapboxGL::MapChangeRegionDidChangeAnimated);
+    }
+}
+
+void QMapboxGLMapObserver::onWillStartLoadingMap()
+{
+    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
+}
+
+void QMapboxGLMapObserver::onDidFinishLoadingMap()
+{
+    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingMap);
+}
+
+void QMapboxGLMapObserver::onDidFailLoadingMap(std::exception_ptr)
+{
+    emit mapChanged(QMapboxGL::MapChangeDidFailLoadingMap);
+}
+
+void QMapboxGLMapObserver::onWillStartRenderingFrame()
+{
+    emit mapChanged(QMapboxGL::MapChangeWillStartRenderingFrame);
+}
+
+void QMapboxGLMapObserver::onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode mode)
+{
+    if (mode == mbgl::MapObserver::RenderMode::Partial) {
+        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrame);
+    } else {
+        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingFrameFullyRendered);
+    }
+}
+
+void QMapboxGLMapObserver::onWillStartRenderingMap()
+{
+    emit mapChanged(QMapboxGL::MapChangeWillStartLoadingMap);
+}
+
+void QMapboxGLMapObserver::onDidFinishRenderingMap(mbgl::MapObserver::RenderMode mode)
+{
+    if (mode == mbgl::MapObserver::RenderMode::Partial) {
+        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMap);
+    } else {
+        emit mapChanged(QMapboxGL::MapChangeDidFinishRenderingMapFullyRendered);
+    }
+}
+
+void QMapboxGLMapObserver::onDidFinishLoadingStyle()
+{
+    emit mapChanged(QMapboxGL::MapChangeDidFinishLoadingStyle);
+}
+
+void QMapboxGLMapObserver::onSourceChanged(mbgl::style::Source&)
+{
+    std::string attribution;
+    for (const auto& source : d_ptr->mapObj->getStyle().getSources()) {
+        // Avoid duplicates by using the most complete attribution HTML snippet.
+        if (source->getAttribution() && (attribution.size() < source->getAttribution()->size()))
+            attribution = *source->getAttribution();
+    }
+    emit copyrightsChanged(QString::fromStdString(attribution));
+    emit mapChanged(QMapboxGL::MapChangeSourceDidChange);
+}

platform/qt/src/qmapboxgl_map_observer.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "qmapboxgl.hpp"
+
+#include <mbgl/map/map_observer.hpp>
+#include <mbgl/style/style.hpp>
+
+#include <QObject>
+
+#include <exception>
+#include <memory>
+
+class QMapboxGLPrivate;
+
+class QMapboxGLMapObserver : public QObject, public mbgl::MapObserver
+{
+    Q_OBJECT
+
+public:
+    explicit QMapboxGLMapObserver(QMapboxGLPrivate *);
+    virtual ~QMapboxGLMapObserver();
+
+    // mbgl::MapObserver implementation.
+    void onCameraWillChange(mbgl::MapObserver::CameraChangeMode) final;
+    void onCameraIsChanging() final;
+    void onCameraDidChange(mbgl::MapObserver::CameraChangeMode) final;
+    void onWillStartLoadingMap() final;
+    void onDidFinishLoadingMap() final;
+    void onDidFailLoadingMap(std::exception_ptr) final;
+    void onWillStartRenderingFrame() final;
+    void onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode) final;
+    void onWillStartRenderingMap() final;
+    void onDidFinishRenderingMap(mbgl::MapObserver::RenderMode) final;
+    void onDidFinishLoadingStyle() final;
+    void onSourceChanged(mbgl::style::Source&) final;
+
+signals:
+    void mapChanged(QMapboxGL::MapChange);
+    void copyrightsChanged(const QString &copyrightsHtml);
+
+private:
+    Q_DISABLE_COPY(QMapboxGLMapObserver)
+
+    QMapboxGLPrivate *d_ptr;
+};

platform/qt/src/qmapboxgl_map_renderer.cpp

@@ -0,0 +1,43 @@
+#include "qmapboxgl_map_renderer.hpp"
+
+#include <QtGlobal>
+
+QMapboxGLMapRenderer::QMapboxGLMapRenderer(qreal pixelRatio,
+        mbgl::DefaultFileSource &fs, mbgl::ThreadPool &tp, QMapboxGLSettings::GLContextMode mode)
+    : m_renderer(std::make_unique<mbgl::Renderer>(m_backend, pixelRatio, fs, tp, static_cast<mbgl::GLContextMode>(mode)))
+{
+}
+
+QMapboxGLMapRenderer::~QMapboxGLMapRenderer()
+{
+}
+
+void QMapboxGLMapRenderer::updateParameters(std::shared_ptr<mbgl::UpdateParameters> newParameters)
+{
+    std::lock_guard<std::mutex> lock(m_updateMutex);
+    m_updateParameters = std::move(newParameters);
+}
+
+void QMapboxGLMapRenderer::updateFramebufferSize(const mbgl::Size &size)
+{
+    std::lock_guard<std::mutex> lock(m_updateMutex);
+    m_backend.setFramebufferSize(size);
+}
+
+void QMapboxGLMapRenderer::render()
+{
+    std::shared_ptr<mbgl::UpdateParameters> params;
+    {
+        // Lock on the parameters
+        std::unique_lock<std::mutex> lock(m_updateMutex);
+        if (!m_updateParameters) return;
+
+        // Hold on to the update parameters during render
+        params = m_updateParameters;
+    }
+
+    // The OpenGL implementation automatically enables the OpenGL context for us.
+    mbgl::BackendScope scope(m_backend, mbgl::BackendScope::ScopeType::Implicit);
+
+    m_renderer->render(*params);
+}

platform/qt/src/qmapboxgl_map_renderer.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "qmapboxgl.hpp"
+#include "qmapboxgl_renderer_backend.hpp"
+
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/renderer/renderer_backend.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/util/shared_thread_pool.hpp>
+
+#include <memory>
+#include <mutex>
+
+namespace mbgl {
+class Renderer;
+class UpdateParameters;
+} // namespace mbgl
+
+class QMapboxGLRendererBackend;
+
+class QMapboxGLMapRenderer
+{
+public:
+    QMapboxGLMapRenderer(qreal pixelRatio, mbgl::DefaultFileSource &,
+            mbgl::ThreadPool &, QMapboxGLSettings::GLContextMode);
+    virtual ~QMapboxGLMapRenderer();
+
+    void render();
+
+    // Thread-safe, called by the Frontend
+    void updateParameters(std::shared_ptr<mbgl::UpdateParameters>);
+    void updateFramebufferSize(const mbgl::Size &size);
+
+private:
+    Q_DISABLE_COPY(QMapboxGLMapRenderer)
+
+    std::mutex m_updateMutex;
+    std::shared_ptr<mbgl::UpdateParameters> m_updateParameters;
+
+    QMapboxGLRendererBackend m_backend;
+    std::unique_ptr<mbgl::Renderer> m_renderer;
+};

platform/qt/src/qmapboxgl_p.hpp

@@ -1,22 +1,23 @@
 #pragma once
 
 #include "qmapboxgl.hpp"
-#include "qmapboxgl_renderer_frontend_p.hpp"
+#include "qmapboxgl_map_observer.hpp"
+#include "qmapboxgl_map_renderer.hpp"
 
 #include <mbgl/actor/actor.hpp>
 #include <mbgl/map/map.hpp>
-#include <mbgl/renderer/renderer_backend.hpp>
-#include <mbgl/util/default_thread_pool.hpp>
+#include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/storage/default_file_source.hpp>
-#include <mbgl/util/geo.hpp>
 #include <mbgl/storage/resource_transform.hpp>
+#include <mbgl/util/default_thread_pool.hpp>
+#include <mbgl/util/geo.hpp>
 
 #include <QObject>
 #include <QSize>
 
 #include <memory>
 
-class QMapboxGLPrivate : public QObject, public mbgl::RendererBackend, public mbgl::MapObserver
+class QMapboxGLPrivate : public QObject, public mbgl::RendererFrontend
 {
     Q_OBJECT
 
@@ -24,55 +25,27 @@ public:
     explicit QMapboxGLPrivate(QMapboxGL *, const QMapboxGLSettings &, const QSize &size, qreal pixelRatio);
     virtual ~QMapboxGLPrivate();
 
-
-    // mbgl::RendererBackend implementation.
-    void bind() final;
-    mbgl::Size getFramebufferSize() const final;
-    void updateAssumedState() final;
-    void activate() final {}
-    void deactivate() final {}
-
-    // mbgl::MapObserver implementation.
-    void onCameraWillChange(mbgl::MapObserver::CameraChangeMode) final;
-    void onCameraIsChanging() final;
-    void onCameraDidChange(mbgl::MapObserver::CameraChangeMode) final;
-    void onWillStartLoadingMap() final;
-    void onDidFinishLoadingMap() final;
-    void onDidFailLoadingMap(std::exception_ptr) final;
-    void onWillStartRenderingFrame() final;
-    void onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode) final;
-    void onWillStartRenderingMap() final;
-    void onDidFinishRenderingMap(mbgl::MapObserver::RenderMode) final;
-    void onDidFinishLoadingStyle() final;
-    void onSourceChanged(mbgl::style::Source&) final;
+    // mbgl::RendererFrontend implementation.
+    void reset() final {}
+    void setObserver(mbgl::RendererObserver &) final {}
+    void update(std::shared_ptr<mbgl::UpdateParameters>) final;
 
     mbgl::EdgeInsets margins;
-    QSize size { 0, 0 };
-    QSize fbSize { 0, 0 };
-    quint32 fbObject = 0;
 
     QMapboxGL *q_ptr { nullptr };
 
     std::shared_ptr<mbgl::DefaultFileSource> fileSourceObj;
     std::shared_ptr<mbgl::ThreadPool> threadPool;
-    std::unique_ptr<QMapboxGLRendererFrontend> frontend;
     std::unique_ptr<mbgl::Map> mapObj;
 
-    bool dirty { false };
-
-private:
-    mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) override;
-
-public slots:
-    void connectionEstablished();
-    void invalidate();
-    void render();
+    std::unique_ptr<QMapboxGLMapObserver> mapObserver;
+    std::unique_ptr<QMapboxGLMapRenderer> mapRenderer;
 
 signals:
     void needsRendering();
-    void mapChanged(QMapboxGL::MapChange);
-    void copyrightsChanged(const QString &copyrightsHtml);
 
 private:
-    std::unique_ptr< mbgl::Actor<mbgl::ResourceTransform> > m_resourceTransform;
+    Q_DISABLE_COPY(QMapboxGLPrivate)
+
+    std::unique_ptr<mbgl::Actor<mbgl::ResourceTransform>> m_resourceTransform;
 };

platform/qt/src/qmapboxgl_renderer_backend.cpp

@@ -0,0 +1,40 @@
+#include "qmapboxgl_renderer_backend.hpp"
+
+#include <QtGlobal>
+
+#if QT_VERSION >= 0x050000
+#include <QOpenGLContext>
+#else
+#include <QGLContext>
+#endif
+
+void QMapboxGLRendererBackend::updateAssumedState()
+{
+    assumeFramebufferBinding(ImplicitFramebufferBinding);
+    assumeViewport(0, 0, { 800, 600 });
+}
+
+mbgl::Size QMapboxGLRendererBackend::getFramebufferSize() const
+{
+    return m_size;
+}
+
+void QMapboxGLRendererBackend::setFramebufferSize(const mbgl::Size &size)
+{
+    m_size = size;
+}
+
+/*!
+    Initializes an OpenGL extension function such as Vertex Array Objects (VAOs),
+    required by Mapbox GL Native engine.
+*/
+mbgl::gl::ProcAddress QMapboxGLRendererBackend::getExtensionFunctionPointer(const char* name)
+{
+#if QT_VERSION >= 0x050000
+    QOpenGLContext* thisContext = QOpenGLContext::currentContext();
+    return thisContext->getProcAddress(name);
+#else
+    const QGLContext* thisContext = QGLContext::currentContext();
+    return reinterpret_cast<mbgl::gl::ProcAddress>(thisContext->getProcAddress(name));
+#endif
+}

platform/qt/src/qmapboxgl_renderer_backend.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "qmapboxgl.hpp"
+
+#include <mbgl/renderer/renderer_backend.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/util/shared_thread_pool.hpp>
+
+class QMapboxGLRendererBackend : public mbgl::RendererBackend
+{
+public:
+    QMapboxGLRendererBackend() = default;
+    virtual ~QMapboxGLRendererBackend() = default;
+
+    // mbgl::RendererBackend implementation
+    void updateAssumedState() final;
+    void bind() final {}
+    mbgl::Size getFramebufferSize() const final;
+
+    void setFramebufferSize(const mbgl::Size &);
+
+protected:
+    mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) final;
+
+    // No-op, implicit mode.
+    void activate() final {}
+    void deactivate() final {}
+
+private:
+    mbgl::Size m_size = { 0, 0 };
+
+    Q_DISABLE_COPY(QMapboxGLRendererBackend)
+};

platform/qt/src/qmapboxgl_renderer_frontend_p.cpp

@@ -1,37 +0,0 @@
-#include "qmapboxgl_renderer_frontend_p.hpp"
-
-#include <mbgl/renderer/backend_scope.hpp>
-#include <mbgl/renderer/renderer.hpp>
-
-QMapboxGLRendererFrontend::QMapboxGLRendererFrontend(std::unique_ptr<mbgl::Renderer> renderer_, mbgl::RendererBackend& backend_)
-    : renderer(std::move(renderer_))
-    , backend(backend_) {
-}
-
-QMapboxGLRendererFrontend::~QMapboxGLRendererFrontend() = default;
-
-void QMapboxGLRendererFrontend::reset() {
-    if (renderer) {
-        renderer.reset();
-    }
-}
-
-void QMapboxGLRendererFrontend::update(std::shared_ptr<mbgl::UpdateParameters> updateParameters_) {
-    updateParameters = updateParameters_;
-    emit updated();
-}
-
-void QMapboxGLRendererFrontend::setObserver(mbgl::RendererObserver& observer_) {
-    if (!renderer) return;
-    
-    renderer->setObserver(&observer_);
-}
-
-void QMapboxGLRendererFrontend::render() {
-    if (!renderer || !updateParameters) return;
-    
-    // The OpenGL implementation automatically enables the OpenGL context for us.
-    mbgl::BackendScope scope { backend, mbgl::BackendScope::ScopeType::Implicit };
-    
-    renderer->render(*updateParameters);
-}

platform/qt/src/qmapboxgl_renderer_frontend_p.hpp

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <mbgl/renderer/renderer_backend.hpp>
-#include <mbgl/renderer/renderer_frontend.hpp>
-
-#include <QObject>
-
-namespace mbgl {
-    class Renderer;
-} // namespace mbgl
-
-class QMapboxGLRendererFrontend : public QObject, public mbgl::RendererFrontend
-{
-    Q_OBJECT
-
-public:
-    explicit QMapboxGLRendererFrontend(std::unique_ptr<mbgl::Renderer>, mbgl::RendererBackend&);
-    ~QMapboxGLRendererFrontend() override;
-    
-    void reset() override;
-    void setObserver(mbgl::RendererObserver&) override;
-
-    void update(std::shared_ptr<mbgl::UpdateParameters>) override;
-
-public slots:
-    void render();
-
-signals:
-    void updated();
-    
-private:
-    std::unique_ptr<mbgl::Renderer> renderer;
-    mbgl::RendererBackend& backend;
-    std::shared_ptr<mbgl::UpdateParameters> updateParameters;
-};