Bump Mapbox GL Native

mapbox-gl-native @ 0ef7b7154f6d4498077a83db5c486c61bc34938c

9 files changed, 623 insertions, 278 deletions

diff --git a/platform/default/mbgl/gl/headless_frontend.cpp b/platform/default/mbgl/gl/headless_frontend.cpp
index 5d2932258a..9df35657b0 100644
--- a/platform/default/mbgl/gl/headless_frontend.cpp
+++ b/platform/default/mbgl/gl/headless_frontend.cpp
@@ -1,15 +1,17 @@
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/renderer/renderer.hpp>
+#include <mbgl/renderer/update_parameters.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/transform_state.hpp>
 #include <mbgl/util/run_loop.hpp>
 
 namespace mbgl {
 
-HeadlessFrontend::HeadlessFrontend(float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir)
-    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSource, scheduler, programCacheDir) {
+HeadlessFrontend::HeadlessFrontend(float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir, GLContextMode mode)
+    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSource, scheduler, programCacheDir, mode) {
 }
 
-HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir)
+HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir, GLContextMode mode)
     : size(size_),
     pixelRatio(pixelRatio_),
     backend({ static_cast<uint32_t>(size.width * pixelRatio),
@@ -20,7 +22,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fi
             renderer->render(*updateParameters);
         }
     }),
-    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, scheduler, GLContextMode::Unique, programCacheDir)) {
+    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, scheduler, mode, programCacheDir)) {
 }
 
 HeadlessFrontend::~HeadlessFrontend() = default;
@@ -83,4 +85,12 @@ PremultipliedImage HeadlessFrontend::render(Map& map) {
     return result;
 }
 
+optional<TransformState> HeadlessFrontend::getTransformState() const {
+    if (updateParameters) {
+        return updateParameters->transformState;
+    } else {
+        return {};
+    }
+}
+
 } // namespace mbgl
diff --git a/platform/default/mbgl/gl/headless_frontend.hpp b/platform/default/mbgl/gl/headless_frontend.hpp
index 33503bc13b..0530d84a25 100644
--- a/platform/default/mbgl/gl/headless_frontend.hpp
+++ b/platform/default/mbgl/gl/headless_frontend.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/renderer/mode.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/gl/headless_backend.hpp>
 #include <mbgl/util/async_task.hpp>
@@ -14,11 +15,12 @@ class Scheduler;
 class Renderer;
 class RendererBackend;
 class Map;
+class TransformState;
 
 class HeadlessFrontend : public RendererFrontend {
 public:
-    HeadlessFrontend(float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {});
-    HeadlessFrontend(Size, float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {});
+    HeadlessFrontend(float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique);
+    HeadlessFrontend(Size, float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique);
     ~HeadlessFrontend() override;
 
     void reset() override;
@@ -34,6 +36,8 @@ public:
     PremultipliedImage readStillImage();
     PremultipliedImage render(Map&);
 
+    optional<TransformState> getTransformState() const;
+
 private:
     Size size;
     float pixelRatio;
diff --git a/platform/default/mbgl/map/map_snapshotter.cpp b/platform/default/mbgl/map/map_snapshotter.cpp
index 95c46344fe..7b4ec5913b 100644
--- a/platform/default/mbgl/map/map_snapshotter.cpp
+++ b/platform/default/mbgl/map/map_snapshotter.cpp
@@ -3,9 +3,11 @@
 #include <mbgl/actor/actor_ref.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/transform_state.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/util/event.hpp>
+#include <mbgl/map/transform.hpp>
 
 namespace mbgl {
 
@@ -20,6 +22,18 @@ public:
          const optional<LatLngBounds> region,
          const optional<std::string> programCacheDir);
 
+    void setStyleURL(std::string styleURL);
+    std::string getStyleURL() const;
+
+    void setSize(Size);
+    Size getSize() const;
+
+    void setCameraOptions(CameraOptions);
+    CameraOptions getCameraOptions() const;
+
+    void setRegion(LatLngBounds);
+    LatLngBounds getRegion() const;
+
     void snapshot(ActorRef<MapSnapshotter::Callback>);
 
 private:
@@ -44,18 +58,80 @@ MapSnapshotter::Impl::Impl(FileSource& fileSource,
 
     // Set region, if specified
     if (region) {
-        mbgl::EdgeInsets insets = { 0, 0, 0, 0 };
-        std::vector<LatLng> latLngs = { region->southwest(), region->northeast() };
-        map.jumpTo(map.cameraForLatLngs(latLngs, insets));
+        this->setRegion(*region);
     }
 }
 
 void MapSnapshotter::Impl::snapshot(ActorRef<MapSnapshotter::Callback> callback) {
     map.renderStill([this, callback = std::move(callback)] (std::exception_ptr error) mutable {
-        callback.invoke(&MapSnapshotter::Callback::operator(), error, error ? PremultipliedImage() : frontend.readStillImage());
+
+        // Create lambda that captures the current transform state
+        // and can be used to translate for geographic to screen
+        // coordinates
+        assert (frontend.getTransformState());
+        PointForFn pointForFn { [=, center=map.getLatLng(), transformState = *frontend.getTransformState()] (const LatLng& latLng) {
+            LatLng unwrappedLatLng = latLng.wrapped();
+            unwrappedLatLng.unwrapForShortestPath(center);
+            Transform transform { transformState };
+            return transform.latLngToScreenCoordinate(unwrappedLatLng);
+        }};
+
+        // Collect all source attributions
+        std::vector<std::string> attributions;
+        for (auto source : map.getStyle().getSources()) {
+            auto attribution = source->getAttribution();
+            if (attribution) {
+                attributions.push_back(*attribution);
+            }
+        }
+
+        // Invoke callback
+        callback.invoke(
+                &MapSnapshotter::Callback::operator(),
+                error,
+                error ? PremultipliedImage() : frontend.readStillImage(),
+                std::move(attributions),
+                std::move(pointForFn)
+        );
     });
 }
 
+void MapSnapshotter::Impl::setStyleURL(std::string styleURL) {
+    map.getStyle().loadURL(styleURL);
+}
+
+std::string MapSnapshotter::Impl::getStyleURL() const {
+    return map.getStyle().getURL();
+}
+
+void MapSnapshotter::Impl::setSize(Size size) {
+    map.setSize(size);
+    frontend.setSize(size);
+}
+
+Size MapSnapshotter::Impl::getSize() const {
+    return map.getSize();
+}
+
+void MapSnapshotter::Impl::setCameraOptions(CameraOptions cameraOptions) {
+    map.jumpTo(cameraOptions);
+}
+
+CameraOptions MapSnapshotter::Impl::getCameraOptions() const {
+    EdgeInsets insets;
+    return map.getCameraOptions(insets);
+}
+
+void MapSnapshotter::Impl::setRegion(LatLngBounds region) {
+    mbgl::EdgeInsets insets = { 0, 0, 0, 0 };
+    std::vector<LatLng> latLngs = { region.southwest(), region.northeast() };
+    map.jumpTo(map.cameraForLatLngs(latLngs, insets));
+}
+
+LatLngBounds MapSnapshotter::Impl::getRegion() const {
+    return map.latLngBoundsForCamera(getCameraOptions());
+}
+
 MapSnapshotter::MapSnapshotter(FileSource& fileSource,
                                Scheduler& scheduler,
                                const std::string& styleURL,
@@ -70,7 +146,39 @@ MapSnapshotter::MapSnapshotter(FileSource& fileSource,
 MapSnapshotter::~MapSnapshotter() = default;
 
 void MapSnapshotter::snapshot(ActorRef<MapSnapshotter::Callback> callback) {
-   impl->actor().invoke(&Impl::snapshot, std::move(callback));
+    impl->actor().invoke(&Impl::snapshot, std::move(callback));
+}
+
+void MapSnapshotter::setStyleURL(const std::string& styleURL) {
+    impl->actor().invoke(&Impl::setStyleURL, styleURL);
+}
+
+std::string MapSnapshotter::getStyleURL() const {
+    return impl->actor().ask(&Impl::getStyleURL).get();
+}
+
+void MapSnapshotter::setSize(const Size& size) {
+    impl->actor().invoke(&Impl::setSize, size);
+}
+
+Size MapSnapshotter::getSize() const {
+    return impl->actor().ask(&Impl::getSize).get();
+}
+
+void MapSnapshotter::setCameraOptions(const CameraOptions& options) {
+    impl->actor().invoke(&Impl::setCameraOptions, options);
+}
+
+CameraOptions MapSnapshotter::getCameraOptions() const {
+    return impl->actor().ask(&Impl::getCameraOptions).get();
+}
+
+void MapSnapshotter::setRegion(const LatLngBounds& bounds) {
+    impl->actor().invoke(&Impl::setRegion, std::move(bounds));
+}
+
+LatLngBounds MapSnapshotter::getRegion() const {
+    return impl->actor().ask(&Impl::getRegion).get();
 }
 
 } // namespace mbgl
diff --git a/platform/default/mbgl/map/map_snapshotter.hpp b/platform/default/mbgl/map/map_snapshotter.hpp
index 0afa848fd8..985396e5a3 100644
--- a/platform/default/mbgl/map/map_snapshotter.hpp
+++ b/platform/default/mbgl/map/map_snapshotter.hpp
@@ -3,9 +3,12 @@
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/thread.hpp>
 #include <mbgl/util/optional.hpp>
+#include <mbgl/util/geo.hpp>
 
 #include <exception>
+#include <memory>
 #include <string>
+#include <vector>
 #include <functional>
 
 namespace mbgl {
@@ -16,6 +19,10 @@ class FileSource;
 class Size;
 class LatLngBounds;
 
+namespace style {
+class Style;
+} // namespace style
+
 class MapSnapshotter {
 public:
     MapSnapshotter(FileSource& fileSource,
@@ -29,7 +36,21 @@ public:
 
     ~MapSnapshotter();
 
-    using Callback = std::function<void (std::exception_ptr, PremultipliedImage)>;
+    void setStyleURL(const std::string& styleURL);
+    std::string getStyleURL() const;
+
+    void setSize(const Size&);
+    Size getSize() const;
+
+    void setCameraOptions(const CameraOptions&);
+    CameraOptions getCameraOptions() const;
+
+    void setRegion(const LatLngBounds&);
+    LatLngBounds getRegion() const;
+
+    using PointForFn = std::function<ScreenCoordinate (const LatLng&)>;
+    using Attributions = std::vector<std::string>;
+    using Callback = std::function<void (std::exception_ptr, PremultipliedImage, Attributions, PointForFn)>;
     void snapshot(ActorRef<Callback>);
 
 private:
diff --git a/platform/qt/mbgl/gl/gl_impl.hpp b/platform/qt/mbgl/gl/gl_impl.hpp
new file mode 100644
index 0000000000..a9f720db7c
--- /dev/null
+++ b/platform/qt/mbgl/gl/gl_impl.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <QtGlobal>
+
+// Qt4
+#if QT_VERSION < 0x050000
+    #if MBGL_USE_GLES2
+        #define GL_GLEXT_PROTOTYPES
+        #include <GLES2/gl2.h>
+        #include <GLES2/gl2ext.h>
+    #else
+        #define GL_GLEXT_PROTOTYPES
+        #include <GL/gl.h>
+        #include <GL/glext.h>
+    #endif
+
+// Qt5
+#else
+    #include <QOpenGLContext>
+    #include <QOpenGLFunctions>
+
+    #ifndef GL_RGBA8_OES
+    #define GL_RGBA8_OES GL_RGBA8
+    #endif
+
+    #ifndef GL_DEPTH24_STENCIL8_OES
+    #define GL_DEPTH24_STENCIL8_OES GL_DEPTH24_STENCIL8
+    #endif
+
+    #define glActiveTexture(...) QOpenGLContext::currentContext()->functions()->glActiveTexture(__VA_ARGS__)
+    #define glAttachShader(...) QOpenGLContext::currentContext()->functions()->glAttachShader(__VA_ARGS__)
+    #define glBindAttribLocation(...) QOpenGLContext::currentContext()->functions()->glBindAttribLocation(__VA_ARGS__)
+    #define glBindBuffer(...) QOpenGLContext::currentContext()->functions()->glBindBuffer(__VA_ARGS__)
+    #define glBindFramebuffer(...) QOpenGLContext::currentContext()->functions()->glBindFramebuffer(__VA_ARGS__)
+    #define glBindRenderbuffer(...) QOpenGLContext::currentContext()->functions()->glBindRenderbuffer(__VA_ARGS__)
+    #define glBindTexture(...) QOpenGLContext::currentContext()->functions()->glBindTexture(__VA_ARGS__)
+    #define glBlendColor(...) QOpenGLContext::currentContext()->functions()->glBlendColor(__VA_ARGS__)
+    #define glBlendEquation(...) QOpenGLContext::currentContext()->functions()->glBlendEquation(__VA_ARGS__)
+    #define glBlendEquationSeparate(...) QOpenGLContext::currentContext()->functions()->glBlendEquationSeparate(__VA_ARGS__)
+    #define glBlendFunc(...) QOpenGLContext::currentContext()->functions()->glBlendFunc(__VA_ARGS__)
+    #define glBlendFuncSeparate(...) QOpenGLContext::currentContext()->functions()->glBlendFuncSeparate(__VA_ARGS__)
+    #define glBufferData(...) QOpenGLContext::currentContext()->functions()->glBufferData(__VA_ARGS__)
+    #define glBufferSubData(...) QOpenGLContext::currentContext()->functions()->glBufferSubData(__VA_ARGS__)
+    #define glCheckFramebufferStatus(...) QOpenGLContext::currentContext()->functions()->glCheckFramebufferStatus(__VA_ARGS__)
+    #define glClear(...) QOpenGLContext::currentContext()->functions()->glClear(__VA_ARGS__)
+    #define glClearColor(...) QOpenGLContext::currentContext()->functions()->glClearColor(__VA_ARGS__)
+    #define glClearDepthf(...) QOpenGLContext::currentContext()->functions()->glClearDepthf(__VA_ARGS__)
+    #define glClearStencil(...) QOpenGLContext::currentContext()->functions()->glClearStencil(__VA_ARGS__)
+    #define glColorMask(...) QOpenGLContext::currentContext()->functions()->glColorMask(__VA_ARGS__)
+    #define glCompileShader(...) QOpenGLContext::currentContext()->functions()->glCompileShader(__VA_ARGS__)
+    #define glCompressedTexImage2D(...) QOpenGLContext::currentContext()->functions()->glCompressedTexImage2D(__VA_ARGS__)
+    #define glCompressedTexSubImage2D(...) QOpenGLContext::currentContext()->functions()->glCompressedTexSubImage2D(__VA_ARGS__)
+    #define glCopyTexImage2D(...) QOpenGLContext::currentContext()->functions()->glCopyTexImage2D(__VA_ARGS__)
+    #define glCopyTexSubImage2D(...) QOpenGLContext::currentContext()->functions()->glCopyTexSubImage2D(__VA_ARGS__)
+    #define glCreateProgram(...) QOpenGLContext::currentContext()->functions()->glCreateProgram(__VA_ARGS__)
+    #define glCreateShader(...) QOpenGLContext::currentContext()->functions()->glCreateShader(__VA_ARGS__)
+    #define glCullFace(...) QOpenGLContext::currentContext()->functions()->glCullFace(__VA_ARGS__)
+    #define glDeleteBuffers(...) QOpenGLContext::currentContext()->functions()->glDeleteBuffers(__VA_ARGS__)
+    #define glDeleteFramebuffers(...) QOpenGLContext::currentContext()->functions()->glDeleteFramebuffers(__VA_ARGS__)
+    #define glDeleteProgram(...) QOpenGLContext::currentContext()->functions()->glDeleteProgram(__VA_ARGS__)
+    #define glDeleteRenderbuffers(...) QOpenGLContext::currentContext()->functions()->glDeleteRenderbuffers(__VA_ARGS__)
+    #define glDeleteShader(...) QOpenGLContext::currentContext()->functions()->glDeleteShader(__VA_ARGS__)
+    #define glDeleteTextures(...) QOpenGLContext::currentContext()->functions()->glDeleteTextures(__VA_ARGS__)
+    #define glDepthFunc(...) QOpenGLContext::currentContext()->functions()->glDepthFunc(__VA_ARGS__)
+    #define glDepthMask(...) QOpenGLContext::currentContext()->functions()->glDepthMask(__VA_ARGS__)
+    #define glDepthRangef(...) QOpenGLContext::currentContext()->functions()->glDepthRangef(__VA_ARGS__)
+    #define glDetachShader(...) QOpenGLContext::currentContext()->functions()->glDetachShader(__VA_ARGS__)
+    #define glDisable(...) QOpenGLContext::currentContext()->functions()->glDisable(__VA_ARGS__)
+    #define glDisableVertexAttribArray(...) QOpenGLContext::currentContext()->functions()->glDisableVertexAttribArray(__VA_ARGS__)
+    #define glDrawArrays(...) QOpenGLContext::currentContext()->functions()->glDrawArrays(__VA_ARGS__)
+    #define glDrawElements(...) QOpenGLContext::currentContext()->functions()->glDrawElements(__VA_ARGS__)
+    #define glEnable(...) QOpenGLContext::currentContext()->functions()->glEnable(__VA_ARGS__)
+    #define glEnableVertexAttribArray(...) QOpenGLContext::currentContext()->functions()->glEnableVertexAttribArray(__VA_ARGS__)
+    #define glFinish(...) QOpenGLContext::currentContext()->functions()->glFinish(__VA_ARGS__)
+    #define glFlush(...) QOpenGLContext::currentContext()->functions()->glFlush(__VA_ARGS__)
+    #define glFramebufferRenderbuffer(...) QOpenGLContext::currentContext()->functions()->glFramebufferRenderbuffer(__VA_ARGS__)
+    #define glFramebufferTexture2D(...) QOpenGLContext::currentContext()->functions()->glFramebufferTexture2D(__VA_ARGS__)
+    #define glFrontFace(...) QOpenGLContext::currentContext()->functions()->glFrontFace(__VA_ARGS__)
+    #define glGenBuffers(...) QOpenGLContext::currentContext()->functions()->glGenBuffers(__VA_ARGS__)
+    #define glGenerateMipmap(...) QOpenGLContext::currentContext()->functions()->glGenerateMipmap(__VA_ARGS__)
+    #define glGenFramebuffers(...) QOpenGLContext::currentContext()->functions()->glGenFramebuffers(__VA_ARGS__)
+    #define glGenRenderbuffers(...) QOpenGLContext::currentContext()->functions()->glGenRenderbuffers(__VA_ARGS__)
+    #define glGenTextures(...) QOpenGLContext::currentContext()->functions()->glGenTextures(__VA_ARGS__)
+    #define glGetActiveAttrib(...) QOpenGLContext::currentContext()->functions()->glGetActiveAttrib(__VA_ARGS__)
+    #define glGetActiveUniform(...) QOpenGLContext::currentContext()->functions()->glGetActiveUniform(__VA_ARGS__)
+    #define glGetAttachedShaders(...) QOpenGLContext::currentContext()->functions()->glGetAttachedShaders(__VA_ARGS__)
+    #define glGetAttribLocation(...) QOpenGLContext::currentContext()->functions()->glGetAttribLocation(__VA_ARGS__)
+    #define glGetBooleanv(...) QOpenGLContext::currentContext()->functions()->glGetBooleanv(__VA_ARGS__)
+    #define glGetBufferParameteriv(...) QOpenGLContext::currentContext()->functions()->glGetBufferParameteriv(__VA_ARGS__)
+    #define glGetError(...) QOpenGLContext::currentContext()->functions()->glGetError(__VA_ARGS__)
+    #define glGetFloatv(...) QOpenGLContext::currentContext()->functions()->glGetFloatv(__VA_ARGS__)
+    #define glGetFramebufferAttachmentParameteriv(...) QOpenGLContext::currentContext()->functions()->glGetFramebufferAttachmentParameteriv(__VA_ARGS__)
+    #define glGetIntegerv(...) QOpenGLContext::currentContext()->functions()->glGetIntegerv(__VA_ARGS__)
+    #define glGetProgramInfoLog(...) QOpenGLContext::currentContext()->functions()->glGetProgramInfoLog(__VA_ARGS__)
+    #define glGetProgramiv(...) QOpenGLContext::currentContext()->functions()->glGetProgramiv(__VA_ARGS__)
+    #define glGetRenderbufferParameteriv(...) QOpenGLContext::currentContext()->functions()->glGetRenderbufferParameteriv(__VA_ARGS__)
+    #define glGetShaderInfoLog(...) QOpenGLContext::currentContext()->functions()->glGetShaderInfoLog(__VA_ARGS__)
+    #define glGetShaderiv(...) QOpenGLContext::currentContext()->functions()->glGetShaderiv(__VA_ARGS__)
+    #define glGetShaderPrecisionFormat(...) QOpenGLContext::currentContext()->functions()->glGetShaderPrecisionFormat(__VA_ARGS__)
+    #define glGetShaderSource(...) QOpenGLContext::currentContext()->functions()->glGetShaderSource(__VA_ARGS__)
+    #define glGetString(...) QOpenGLContext::currentContext()->functions()->glGetString(__VA_ARGS__)
+    #define glGetTexParameterfv(...) QOpenGLContext::currentContext()->functions()->glGetTexParameterfv(__VA_ARGS__)
+    #define glGetTexParameteriv(...) QOpenGLContext::currentContext()->functions()->glGetTexParameteriv(__VA_ARGS__)
+    #define glGetUniformfv(...) QOpenGLContext::currentContext()->functions()->glGetUniformfv(__VA_ARGS__)
+    #define glGetUniformiv(...) QOpenGLContext::currentContext()->functions()->glGetUniformiv(__VA_ARGS__)
+    #define glGetUniformLocation(...) QOpenGLContext::currentContext()->functions()->glGetUniformLocation(__VA_ARGS__)
+    #define glGetVertexAttribfv(...) QOpenGLContext::currentContext()->functions()->glGetVertexAttribfv(__VA_ARGS__)
+    #define glGetVertexAttribiv(...) QOpenGLContext::currentContext()->functions()->glGetVertexAttribiv(__VA_ARGS__)
+    #define glGetVertexAttribPointerv(...) QOpenGLContext::currentContext()->functions()->glGetVertexAttribPointerv(__VA_ARGS__)
+    #define glHint(...) QOpenGLContext::currentContext()->functions()->glHint(__VA_ARGS__)
+    #define glIsBuffer(...) QOpenGLContext::currentContext()->functions()->glIsBuffer(__VA_ARGS__)
+    #define glIsEnabled(...) QOpenGLContext::currentContext()->functions()->glIsEnabled(__VA_ARGS__)
+    #define glIsFramebuffer(...) QOpenGLContext::currentContext()->functions()->glIsFramebuffer(__VA_ARGS__)
+    #define glIsProgram(...) QOpenGLContext::currentContext()->functions()->glIsProgram(__VA_ARGS__)
+    #define glIsRenderbuffer(...) QOpenGLContext::currentContext()->functions()->glIsRenderbuffer(__VA_ARGS__)
+    #define glIsShader(...) QOpenGLContext::currentContext()->functions()->glIsShader(__VA_ARGS__)
+    #define glIsTexture(...) QOpenGLContext::currentContext()->functions()->glIsTexture(__VA_ARGS__)
+    #define glLineWidth(...) QOpenGLContext::currentContext()->functions()->glLineWidth(__VA_ARGS__)
+    #define glLinkProgram(...) QOpenGLContext::currentContext()->functions()->glLinkProgram(__VA_ARGS__)
+    #define glPixelStorei(...) QOpenGLContext::currentContext()->functions()->glPixelStorei(__VA_ARGS__)
+    #define glPolygonOffset(...) QOpenGLContext::currentContext()->functions()->glPolygonOffset(__VA_ARGS__)
+    #define glReadPixels(...) QOpenGLContext::currentContext()->functions()->glReadPixels(__VA_ARGS__)
+    #define glReleaseShaderCompiler(...) QOpenGLContext::currentContext()->functions()->glReleaseShaderCompiler(__VA_ARGS__)
+    #define glRenderbufferStorage(...) QOpenGLContext::currentContext()->functions()->glRenderbufferStorage(__VA_ARGS__)
+    #define glSampleCoverage(...) QOpenGLContext::currentContext()->functions()->glSampleCoverage(__VA_ARGS__)
+    #define glScissor(...) QOpenGLContext::currentContext()->functions()->glScissor(__VA_ARGS__)
+    #define glShaderBinary(...) QOpenGLContext::currentContext()->functions()->glShaderBinary(__VA_ARGS__)
+    #define glShaderSource(...) QOpenGLContext::currentContext()->functions()->glShaderSource(__VA_ARGS__)
+    #define glStencilFunc(...) QOpenGLContext::currentContext()->functions()->glStencilFunc(__VA_ARGS__)
+    #define glStencilFuncSeparate(...) QOpenGLContext::currentContext()->functions()->glStencilFuncSeparate(__VA_ARGS__)
+    #define glStencilMask(...) QOpenGLContext::currentContext()->functions()->glStencilMask(__VA_ARGS__)
+    #define glStencilMaskSeparate(...) QOpenGLContext::currentContext()->functions()->glStencilMaskSeparate(__VA_ARGS__)
+    #define glStencilOp(...) QOpenGLContext::currentContext()->functions()->glStencilOp(__VA_ARGS__)
+    #define glStencilOpSeparate(...) QOpenGLContext::currentContext()->functions()->glStencilOpSeparate(__VA_ARGS__)
+    #define glTexImage2D(...) QOpenGLContext::currentContext()->functions()->glTexImage2D(__VA_ARGS__)
+    #define glTexLevelParameteriv(...) QOpenGLContext::currentContext()->functions()->glTexLevelParameteriv(__VA_ARGS__)
+    #define glTexParameterf(...) QOpenGLContext::currentContext()->functions()->glTexParameterf(__VA_ARGS__)
+    #define glTexParameterfv(...) QOpenGLContext::currentContext()->functions()->glTexParameterfv(__VA_ARGS__)
+    #define glTexParameteri(...) QOpenGLContext::currentContext()->functions()->glTexParameteri(__VA_ARGS__)
+    #define glTexParameteriv(...) QOpenGLContext::currentContext()->functions()->glTexParameteriv(__VA_ARGS__)
+    #define glTexSubImage2D(...) QOpenGLContext::currentContext()->functions()->glTexSubImage2D(__VA_ARGS__)
+    #define glUniform1f(...) QOpenGLContext::currentContext()->functions()->glUniform1f(__VA_ARGS__)
+    #define glUniform1fv(...) QOpenGLContext::currentContext()->functions()->glUniform1fv(__VA_ARGS__)
+    #define glUniform1i(...) QOpenGLContext::currentContext()->functions()->glUniform1i(__VA_ARGS__)
+    #define glUniform1iv(...) QOpenGLContext::currentContext()->functions()->glUniform1iv(__VA_ARGS__)
+    #define glUniform2f(...) QOpenGLContext::currentContext()->functions()->glUniform2f(__VA_ARGS__)
+    #define glUniform2fv(...) QOpenGLContext::currentContext()->functions()->glUniform2fv(__VA_ARGS__)
+    #define glUniform2i(...) QOpenGLContext::currentContext()->functions()->glUniform2i(__VA_ARGS__)
+    #define glUniform2iv(...) QOpenGLContext::currentContext()->functions()->glUniform2iv(__VA_ARGS__)
+    #define glUniform3f(...) QOpenGLContext::currentContext()->functions()->glUniform3f(__VA_ARGS__)
+    #define glUniform3fv(...) QOpenGLContext::currentContext()->functions()->glUniform3fv(__VA_ARGS__)
+    #define glUniform3i(...) QOpenGLContext::currentContext()->functions()->glUniform3i(__VA_ARGS__)
+    #define glUniform3iv(...) QOpenGLContext::currentContext()->functions()->glUniform3iv(__VA_ARGS__)
+    #define glUniform4f(...) QOpenGLContext::currentContext()->functions()->glUniform4f(__VA_ARGS__)
+    #define glUniform4fv(...) QOpenGLContext::currentContext()->functions()->glUniform4fv(__VA_ARGS__)
+    #define glUniform4i(...) QOpenGLContext::currentContext()->functions()->glUniform4i(__VA_ARGS__)
+    #define glUniform4iv(...) QOpenGLContext::currentContext()->functions()->glUniform4iv(__VA_ARGS__)
+    #define glUniformMatrix2fv(...) QOpenGLContext::currentContext()->functions()->glUniformMatrix2fv(__VA_ARGS__)
+    #define glUniformMatrix3fv(...) QOpenGLContext::currentContext()->functions()->glUniformMatrix3fv(__VA_ARGS__)
+    #define glUniformMatrix4fv(...) QOpenGLContext::currentContext()->functions()->glUniformMatrix4fv(__VA_ARGS__)
+    #define glUseProgram(...) QOpenGLContext::currentContext()->functions()->glUseProgram(__VA_ARGS__)
+    #define glValidateProgram(...) QOpenGLContext::currentContext()->functions()->glValidateProgram(__VA_ARGS__)
+    #define glVertexAttrib1f(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib1f(__VA_ARGS__)
+    #define glVertexAttrib1fv(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib1fv(__VA_ARGS__)
+    #define glVertexAttrib2f(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib2f(__VA_ARGS__)
+    #define glVertexAttrib2fv(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib2fv(__VA_ARGS__)
+    #define glVertexAttrib3f(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib3f(__VA_ARGS__)
+    #define glVertexAttrib3fv(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib3fv(__VA_ARGS__)
+    #define glVertexAttrib4f(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib4f(__VA_ARGS__)
+    #define glVertexAttrib4fv(...) QOpenGLContext::currentContext()->functions()->glVertexAttrib4fv(__VA_ARGS__)
+    #define glVertexAttribPointer(...) QOpenGLContext::currentContext()->functions()->glVertexAttribPointer(__VA_ARGS__)
+    #define glViewport(...) QOpenGLContext::currentContext()->functions()->glViewport(__VA_ARGS__)
+#endif
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index 074ef280aa..740bb90202 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -14,7 +14,17 @@
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/source.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/style/filter.hpp>
 #include <mbgl/style/layers/custom_layer.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/style/transition_options.hpp>
 #include <mbgl/style/image.hpp>
diff --git a/platform/qt/src/qt_conversion.hpp b/platform/qt/src/qt_conversion.hpp
index 40d7e5b928..19b0cb54fc 100644
--- a/platform/qt/src/qt_conversion.hpp
+++ b/platform/qt/src/qt_conversion.hpp
@@ -1,120 +1,145 @@
 #pragma once
 
 #include <mbgl/style/conversion.hpp>
-#include <mbgl/util/feature.hpp>
+#include <mbgl/style/conversion/geojson.hpp>
 #include <mbgl/util/optional.hpp>
 
-#include <QMapbox>
-
-#include <QColor>
 #include <QVariant>
+#include <QColor>
+#include <QMapbox>
+#include "qt_geojson.hpp"
 
 namespace mbgl {
 namespace style {
 namespace conversion {
 
-inline bool isUndefined(const QVariant& value) {
-    return value.isNull() || !value.isValid();
-}
+template <>
+class ConversionTraits<QVariant> {
+public:
+    static bool isUndefined(const QVariant& value) {
+        return value.isNull() || !value.isValid();
+    }
 
-inline bool isArray(const QVariant& value) {
-    return value.canConvert(QVariant::List);
-}
+    static bool isArray(const QVariant& value) {
+        return value.canConvert(QVariant::List);
+    }
 
-inline std::size_t arrayLength(const QVariant& value) {
-    return value.toList().size();
-}
+    static std::size_t arrayLength(const QVariant& value) {
+        return value.toList().size();
+    }
 
-inline QVariant arrayMember(const QVariant& value, std::size_t i) {
-    return value.toList()[i];
-}
+    static QVariant arrayMember(const QVariant& value, std::size_t i) {
+        return value.toList()[i];
+    }
 
-inline bool isObject(const QVariant& value) {
-    return value.canConvert(QVariant::Map)
-        || value.type() == QVariant::ByteArray
-#if QT_VERSION >= 0x050000
-        || QString(value.typeName()) == QStringLiteral("QMapbox::Feature");
-#else
-        || QString(value.typeName()) == QString("QMapbox::Feature");
-#endif
-}
+    static bool isObject(const QVariant& value) {
+        return value.canConvert(QVariant::Map)
+            || value.type() == QVariant::ByteArray
+    #if QT_VERSION >= 0x050000
+            || QString(value.typeName()) == QStringLiteral("QMapbox::Feature");
+    #else
+            || QString(value.typeName()) == QString("QMapbox::Feature");
+    #endif
+    }
 
-inline optional<QVariant> objectMember(const QVariant& value, const char* key) {
-    auto map = value.toMap();
-    auto iter = map.constFind(key);
+    static optional<QVariant> objectMember(const QVariant& value, const char* key) {
+        auto map = value.toMap();
+        auto iter = map.constFind(key);
 
-    if (iter != map.constEnd()) {
-        return iter.value();
-    } else {
-        return {};
+        if (iter != map.constEnd()) {
+            return iter.value();
+        } else {
+            return {};
+        }
     }
-}
 
-using EachMemberFn = std::function<optional<Error>(const std::string&, const QVariant&)>;
+    template <class Fn>
+    static optional<Error> eachMember(const QVariant& value, Fn&& fn) {
+        auto map = value.toMap();
+        auto iter = map.constBegin();
 
-optional<Error> eachMember(const QVariant& value, EachMemberFn&& fn) {
-    auto map = value.toMap();
-    auto iter = map.constBegin();
+        while (iter != map.constEnd()) {
+            optional<Error> result = fn(iter.key().toStdString(), QVariant(iter.value()));
+            if (result) {
+                return result;
+            }
 
-    while (iter != map.constEnd()) {
-        optional<Error> result = fn(iter.key().toStdString(), iter.value());
-        if (result) {
-            return result;
+            ++iter;
         }
 
-        ++iter;
+        return {};
     }
 
-    return {};
-}
+    static optional<bool> toBool(const QVariant& value) {
+        if (value.type() == QVariant::Bool) {
+            return value.toBool();
+        } else {
+            return {};
+        }
+    }
 
-inline optional<bool> toBool(const QVariant& value) {
-    if (value.type() == QVariant::Bool) {
-        return value.toBool();
-    } else {
-        return {};
+    static optional<float> toNumber(const QVariant& value) {
+        if (value.type() == QVariant::Int || value.type() == QVariant::Double) {
+            return value.toFloat();
+        } else {
+            return {};
+        }
     }
-}
 
-inline optional<float> toNumber(const QVariant& value) {
-    if (value.type() == QVariant::Int || value.type() == QVariant::Double) {
-        return value.toFloat();
-    } else {
-        return {};
+    static optional<double> toDouble(const QVariant& value) {
+        if (value.type() == QVariant::Int || value.type() == QVariant::Double) {
+            return value.toDouble();
+        } else {
+            return {};
+        }
     }
-}
-inline optional<double> toDouble(const QVariant& value) {
-    if (value.type() == QVariant::Int || value.type() == QVariant::Double) {
-        return value.toDouble();
-    } else {
-        return {};
+
+    static optional<std::string> toString(const QVariant& value) {
+        if (value.type() == QVariant::String) {
+            return value.toString().toStdString();
+        } else if (value.type() == QVariant::Color) {
+            return value.value<QColor>().name().toStdString();
+        } else {
+            return {};
+        }
     }
-}
 
-inline optional<std::string> toString(const QVariant& value) {
-    if (value.type() == QVariant::String) {
-        return value.toString().toStdString();
-    } else if (value.type() == QVariant::Color) {
-        return value.value<QColor>().name().toStdString();
-    } else {
-        return {};
+    static optional<Value> toValue(const QVariant& value) {
+        if (value.type() == QVariant::Bool) {
+            return { value.toBool() };
+        } else if (value.type() == QVariant::String) {
+            return { value.toString().toStdString() };
+        } else if (value.type() == QVariant::Color) {
+            return { value.value<QColor>().name().toStdString() };
+        } else if (value.type() == QVariant::Int) {
+            return { int64_t(value.toInt()) };
+        } else if (value.canConvert(QVariant::Double)) {
+            return { value.toDouble() };
+        } else {
+            return {};
+        }
     }
-}
 
-inline optional<Value> toValue(const QVariant& value) {
-    if (value.type() == QVariant::Bool) {
-        return { value.toBool() };
-    } else if (value.type() == QVariant::String) {
-        return { value.toString().toStdString() };
-    } else if (value.type() == QVariant::Color) {
-        return { value.value<QColor>().name().toStdString() };
-    } else if (value.type() == QVariant::Int) {
-        return { int64_t(value.toInt()) };
-    } else if (value.canConvert(QVariant::Double)) {
-        return { value.toDouble() };
-    } else {
-        return {};
+    static optional<GeoJSON> toGeoJSON(const QVariant& value, Error& error) {
+    #if QT_VERSION >= 0x050000
+        if (value.typeName() == QStringLiteral("QMapbox::Feature")) {
+    #else
+        if (value.typeName() == QString("QMapbox::Feature")) {
+    #endif
+            return GeoJSON { asMapboxGLFeature(value.value<QMapbox::Feature>()) };
+        } else if (value.type() != QVariant::ByteArray) {
+            error = { "JSON data must be in QByteArray" };
+            return {};
+        }
+
+        QByteArray data = value.toByteArray();
+        return parseGeoJSON(std::string(data.constData(), data.size()), error);
     }
+};
+
+template <class T, class...Args>
+optional<T> convert(const QVariant& value, Error& error, Args&&...args) {
+    return convert<T>(Convertible(value), error, std::forward<Args>(args)...);
 }
 
 } // namespace conversion
diff --git a/platform/qt/src/qt_geojson.cpp b/platform/qt/src/qt_geojson.cpp
new file mode 100644
index 0000000000..80377de64d
--- /dev/null
+++ b/platform/qt/src/qt_geojson.cpp
@@ -0,0 +1,166 @@
+#include "qt_geojson.hpp"
+#include <mapbox/geojson.hpp>
+#include <mbgl/util/geometry.hpp>
+#include <mbgl/util/feature.hpp>
+
+namespace QMapbox {
+
+mbgl::Point<double> asMapboxGLPoint(const QMapbox::Coordinate &coordinate) {
+    return mbgl::Point<double> { coordinate.second, coordinate.first };
+}
+
+mbgl::MultiPoint<double> asMapboxGLMultiPoint(const QMapbox::Coordinates &multiPoint) {
+    mbgl::MultiPoint<double> mbglMultiPoint;
+    mbglMultiPoint.reserve(multiPoint.size());
+    for (const auto &point: multiPoint) {
+        mbglMultiPoint.emplace_back(asMapboxGLPoint(point));
+    }
+    return mbglMultiPoint;
+};
+
+mbgl::LineString<double> asMapboxGLLineString(const QMapbox::Coordinates &lineString) {
+    mbgl::LineString<double> mbglLineString;
+    mbglLineString.reserve(lineString.size());
+    for (const auto &coordinate : lineString) {
+        mbglLineString.emplace_back(asMapboxGLPoint(coordinate));
+    }
+    return mbglLineString;
+};
+
+mbgl::MultiLineString<double> asMapboxGLMultiLineString(const QMapbox::CoordinatesCollection &multiLineString) {
+    mbgl::MultiLineString<double> mbglMultiLineString;
+    mbglMultiLineString.reserve(multiLineString.size());
+    for (const auto &lineString : multiLineString) {
+        mbglMultiLineString.emplace_back(std::forward<mbgl::LineString<double>>(asMapboxGLLineString(lineString)));
+    }
+    return mbglMultiLineString;
+};
+
+mbgl::Polygon<double> asMapboxGLPolygon(const QMapbox::CoordinatesCollection &polygon) {
+    mbgl::Polygon<double> mbglPolygon;
+    mbglPolygon.reserve(polygon.size());
+    for (const auto &linearRing : polygon) {
+        mbgl::LinearRing<double> mbglLinearRing;
+        mbglLinearRing.reserve(linearRing.size());
+        for (const auto &coordinate: linearRing) {
+            mbglLinearRing.emplace_back(asMapboxGLPoint(coordinate));
+        }
+        mbglPolygon.emplace_back(std::move(mbglLinearRing));
+    }
+    return mbglPolygon;
+};
+
+mbgl::MultiPolygon<double> asMapboxGLMultiPolygon(const QMapbox::CoordinatesCollections &multiPolygon) {
+    mbgl::MultiPolygon<double> mbglMultiPolygon;
+    mbglMultiPolygon.reserve(multiPolygon.size());
+    for (const auto &polygon : multiPolygon) {
+        mbglMultiPolygon.emplace_back(std::forward<mbgl::Polygon<double>>(asMapboxGLPolygon(polygon)));
+    }
+    return mbglMultiPolygon;
+};
+
+mbgl::Value asMapboxGLPropertyValue(const QVariant &value) {
+    auto valueList = [](const QVariantList &list) {
+        std::vector<mbgl::Value> mbglList;
+        mbglList.reserve(list.size());
+        for (const auto& listValue : list) {
+            mbglList.emplace_back(asMapboxGLPropertyValue(listValue));
+        }
+        return mbglList;
+    };
+
+    auto valueMap = [](const QVariantMap &map) {
+        std::unordered_map<std::string, mbgl::Value> mbglMap;
+        mbglMap.reserve(map.size());
+        auto it = map.constBegin();
+        while (it != map.constEnd()) {
+            mbglMap.emplace(std::make_pair(it.key().toStdString(), asMapboxGLPropertyValue(it.value())));
+            ++it;
+        }
+        return mbglMap;
+    };
+
+    switch (value.type()) {
+#if QT_VERSION >= 0x050000
+    case QMetaType::UnknownType:
+#else
+    case QVariant::Invalid:
+#endif
+        return mbgl::NullValue {};
+    case QMetaType::Bool:
+        return { value.toBool() };
+    case QMetaType::ULongLong:
+        return { uint64_t(value.toULongLong()) };
+    case QMetaType::LongLong:
+        return { int64_t(value.toLongLong()) };
+    case QMetaType::Double:
+        return { value.toDouble() };
+    case QMetaType::QString:
+        return { value.toString().toStdString() };
+    case QMetaType::QVariantList:
+        return valueList(value.toList());
+    case QMetaType::QVariantMap:
+        return valueMap(value.toMap());
+    default:
+        qWarning() << "Unsupported feature property value:" << value;
+        return {};
+    }
+}
+
+mbgl::FeatureIdentifier asMapboxGLFeatureIdentifier(const QVariant &id) {
+    switch (id.type()) {
+#if QT_VERSION >= 0x050000
+    case QMetaType::UnknownType:
+#else
+    case QVariant::Invalid:
+#endif
+        return {};
+    case QMetaType::ULongLong:
+        return { uint64_t(id.toULongLong()) };
+    case QMetaType::LongLong:
+        return { int64_t(id.toLongLong()) };
+    case QMetaType::Double:
+        return { id.toDouble() };
+    case QMetaType::QString:
+        return { id.toString().toStdString() };
+    default:
+        qWarning() << "Unsupported feature identifier:" << id;
+        return {};
+    }
+}
+
+mbgl::Feature asMapboxGLFeature(const QMapbox::Feature &feature) {
+    mbgl::PropertyMap properties;
+    properties.reserve(feature.properties.size());
+    auto it = feature.properties.constBegin();
+    while (it != feature.properties.constEnd()) {
+        properties.emplace(std::make_pair(it.key().toStdString(), asMapboxGLPropertyValue(it.value())));
+    }
+
+    mbgl::FeatureIdentifier id = asMapboxGLFeatureIdentifier(feature.id);
+
+    if (feature.type == QMapbox::Feature::PointType) {
+        const QMapbox::Coordinates &points = feature.geometry.first().first();
+        if (points.size() == 1) {
+            return { asMapboxGLPoint(points.first()), std::move(properties), std::move(id) };
+        } else {
+            return { asMapboxGLMultiPoint(points), std::move(properties), std::move(id) };
+        }
+    } else if (feature.type == QMapbox::Feature::LineStringType) {
+        const QMapbox::CoordinatesCollection &lineStrings = feature.geometry.first();
+        if (lineStrings.size() == 1) {
+            return { asMapboxGLLineString(lineStrings.first()), std::move(properties), std::move(id) };
+        } else {
+            return { asMapboxGLMultiLineString(lineStrings), std::move(properties), std::move(id) };
+        }
+    } else { // PolygonType
+        const QMapbox::CoordinatesCollections &polygons = feature.geometry;
+        if (polygons.size() == 1) {
+            return { asMapboxGLPolygon(polygons.first()), std::move(properties), std::move(id) };
+        } else {
+            return { asMapboxGLMultiPolygon(polygons), std::move(properties), std::move(id) };
+        }
+    }
+};
+
+} // namespace QMapbox
diff --git a/platform/qt/src/qt_geojson.hpp b/platform/qt/src/qt_geojson.hpp
index a6958b7edc..a9c10272ab 100644
--- a/platform/qt/src/qt_geojson.hpp
+++ b/platform/qt/src/qt_geojson.hpp
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <mapbox/geojson.hpp>
-#include <mbgl/style/conversion/geojson.hpp>
+#include <mbgl/util/geometry.hpp>
+#include <mbgl/util/feature.hpp>
 
 #include <QMapbox>
 
@@ -13,187 +14,14 @@
 
 namespace QMapbox {
 
-mbgl::Point<double> asMapboxGLPoint(const QMapbox::Coordinate &coordinate) {
-    return mbgl::Point<double> { coordinate.second, coordinate.first };
-}
-
-mbgl::MultiPoint<double> asMapboxGLMultiPoint(const QMapbox::Coordinates &multiPoint) {
-    mbgl::MultiPoint<double> mbglMultiPoint;
-    mbglMultiPoint.reserve(multiPoint.size());
-    for (const auto &point: multiPoint) {
-        mbglMultiPoint.emplace_back(asMapboxGLPoint(point));
-    }
-    return mbglMultiPoint;
-};
-
-mbgl::LineString<double> asMapboxGLLineString(const QMapbox::Coordinates &lineString) {
-    mbgl::LineString<double> mbglLineString;
-    mbglLineString.reserve(lineString.size());
-    for (const auto &coordinate : lineString) {
-        mbglLineString.emplace_back(asMapboxGLPoint(coordinate));
-    }
-    return mbglLineString;
-};
-
-mbgl::MultiLineString<double> asMapboxGLMultiLineString(const QMapbox::CoordinatesCollection &multiLineString) {
-    mbgl::MultiLineString<double> mbglMultiLineString;
-    mbglMultiLineString.reserve(multiLineString.size());
-    for (const auto &lineString : multiLineString) {
-        mbglMultiLineString.emplace_back(std::forward<mbgl::LineString<double>>(asMapboxGLLineString(lineString)));
-    }
-    return mbglMultiLineString;
-};
-
-mbgl::Polygon<double> asMapboxGLPolygon(const QMapbox::CoordinatesCollection &polygon) {
-    mbgl::Polygon<double> mbglPolygon;
-    mbglPolygon.reserve(polygon.size());
-    for (const auto &linearRing : polygon) {
-        mbgl::LinearRing<double> mbglLinearRing;
-        mbglLinearRing.reserve(linearRing.size());
-        for (const auto &coordinate: linearRing) {
-            mbglLinearRing.emplace_back(asMapboxGLPoint(coordinate));
-        }
-        mbglPolygon.emplace_back(std::move(mbglLinearRing));
-    }
-    return mbglPolygon;
-};
-
-mbgl::MultiPolygon<double> asMapboxGLMultiPolygon(const QMapbox::CoordinatesCollections &multiPolygon) {
-    mbgl::MultiPolygon<double> mbglMultiPolygon;
-    mbglMultiPolygon.reserve(multiPolygon.size());
-    for (const auto &polygon : multiPolygon) {
-        mbglMultiPolygon.emplace_back(std::forward<mbgl::Polygon<double>>(asMapboxGLPolygon(polygon)));
-    }
-    return mbglMultiPolygon;
-};
-
-mbgl::Value asMapboxGLPropertyValue(const QVariant &value) {
-    auto valueList = [](const QVariantList &list) {
-        std::vector<mbgl::Value> mbglList;
-        mbglList.reserve(list.size());
-        for (const auto& listValue : list) {
-            mbglList.emplace_back(asMapboxGLPropertyValue(listValue));
-        }
-        return mbglList;
-    };
-
-    auto valueMap = [](const QVariantMap &map) {
-        std::unordered_map<std::string, mbgl::Value> mbglMap;
-        mbglMap.reserve(map.size());
-        auto it = map.constBegin();
-        while (it != map.constEnd()) {
-            mbglMap.emplace(std::make_pair(it.key().toStdString(), asMapboxGLPropertyValue(it.value())));
-            ++it;
-        }
-        return mbglMap;
-    };
-
-    switch (value.type()) {
-#if QT_VERSION >= 0x050000
-    case QMetaType::UnknownType:
-#else
-    case QVariant::Invalid:
-#endif
-        return mbgl::NullValue {};
-    case QMetaType::Bool:
-        return { value.toBool() };
-    case QMetaType::ULongLong:
-        return { uint64_t(value.toULongLong()) };
-    case QMetaType::LongLong:
-        return { int64_t(value.toLongLong()) };
-    case QMetaType::Double:
-        return { value.toDouble() };
-    case QMetaType::QString:
-        return { value.toString().toStdString() };
-    case QMetaType::QVariantList:
-        return valueList(value.toList());
-    case QMetaType::QVariantMap:
-        return valueMap(value.toMap());
-    default:
-        qWarning() << "Unsupported feature property value:" << value;
-        return {};
-    }
-}
-
-mbgl::FeatureIdentifier asMapboxGLFeatureIdentifier(const QVariant &id) {
-    switch (id.type()) {
-#if QT_VERSION >= 0x050000
-    case QMetaType::UnknownType:
-#else
-    case QVariant::Invalid:
-#endif
-        return {};
-    case QMetaType::ULongLong:
-        return { uint64_t(id.toULongLong()) };
-    case QMetaType::LongLong:
-        return { int64_t(id.toLongLong()) };
-    case QMetaType::Double:
-        return { id.toDouble() };
-    case QMetaType::QString:
-        return { id.toString().toStdString() };
-    default:
-        qWarning() << "Unsupported feature identifier:" << id;
-        return {};
-    }
-}
-
-mbgl::Feature asMapboxGLFeature(const QMapbox::Feature &feature) {
-    mbgl::PropertyMap properties;
-    properties.reserve(feature.properties.size());
-    auto it = feature.properties.constBegin();
-    while (it != feature.properties.constEnd()) {
-        properties.emplace(std::make_pair(it.key().toStdString(), asMapboxGLPropertyValue(it.value())));
-    }
-
-    mbgl::FeatureIdentifier id = asMapboxGLFeatureIdentifier(feature.id);
-
-    if (feature.type == QMapbox::Feature::PointType) {
-        const QMapbox::Coordinates &points = feature.geometry.first().first();
-        if (points.size() == 1) {
-            return { asMapboxGLPoint(points.first()), std::move(properties), std::move(id) };
-        } else {
-            return { asMapboxGLMultiPoint(points), std::move(properties), std::move(id) };
-        }
-    } else if (feature.type == QMapbox::Feature::LineStringType) {
-        const QMapbox::CoordinatesCollection &lineStrings = feature.geometry.first();
-        if (lineStrings.size() == 1) {
-            return { asMapboxGLLineString(lineStrings.first()), std::move(properties), std::move(id) };
-        } else {
-            return { asMapboxGLMultiLineString(lineStrings), std::move(properties), std::move(id) };
-        }
-    } else { // PolygonType
-        const QMapbox::CoordinatesCollections &polygons = feature.geometry;
-        if (polygons.size() == 1) {
-            return { asMapboxGLPolygon(polygons.first()), std::move(properties), std::move(id) };
-        } else {
-            return { asMapboxGLMultiPolygon(polygons), std::move(properties), std::move(id) };
-        }
-    }
-};
+mbgl::Point<double> asMapboxGLPoint(const QMapbox::Coordinate &coordinate);
+mbgl::MultiPoint<double> asMapboxGLMultiPoint(const QMapbox::Coordinates &multiPoint);
+mbgl::LineString<double> asMapboxGLLineString(const QMapbox::Coordinates &lineString);
+mbgl::MultiLineString<double> asMapboxGLMultiLineString(const QMapbox::CoordinatesCollection &multiLineString);
+mbgl::Polygon<double> asMapboxGLPolygon(const QMapbox::CoordinatesCollection &polygon);
+mbgl::MultiPolygon<double> asMapboxGLMultiPolygon(const QMapbox::CoordinatesCollections &multiPolygon);
+mbgl::Value asMapboxGLPropertyValue(const QVariant &value);
+mbgl::FeatureIdentifier asMapboxGLFeatureIdentifier(const QVariant &id);
+mbgl::Feature asMapboxGLFeature(const QMapbox::Feature &feature);
 
 } // namespace QMapbox
-
-namespace mbgl {
-namespace style {
-namespace conversion {
-
-template <>
-optional<GeoJSON> Converter<GeoJSON>::operator()(const QVariant& value, Error& error) const {
-#if QT_VERSION >= 0x050000
-    if (value.typeName() == QStringLiteral("QMapbox::Feature")) {
-#else
-    if (value.typeName() == QString("QMapbox::Feature")) {
-#endif
-        return GeoJSON { asMapboxGLFeature(value.value<QMapbox::Feature>()) };
-    } else if (value.type() != QVariant::ByteArray) {
-        error = { "JSON data must be in QByteArray" };
-        return {};
-    }
-
-    QByteArray data = value.toByteArray();
-    return convert<GeoJSON>(std::string(data.constData(), data.size()), error);
-}
-
-} // namespace conversion
-} // namespace style
-} // namespace mbgl