Bump Mapbox GL Native

mapbox-gl-native @ 10f7af19ce1ec61f37459f9cd75e2a0c89a0c790

23 files changed, 630 insertions, 39 deletions

diff --git a/include/mbgl/actor/message.hpp b/include/mbgl/actor/message.hpp
index 406de425d4..0a20993352 100644
--- a/include/mbgl/actor/message.hpp
+++ b/include/mbgl/actor/message.hpp
@@ -64,6 +64,32 @@ public:
     std::promise<ResultType> promise;
 };
 
+template <class Object, class MemberFn, class ArgsTuple>
+class AskMessageImpl<void, Object, MemberFn, ArgsTuple> : public Message {
+public:
+    AskMessageImpl(std::promise<void> promise_, Object& object_, MemberFn memberFn_, ArgsTuple argsTuple_)
+            : object(object_),
+            memberFn(memberFn_),
+            argsTuple(std::move(argsTuple_)),
+            promise(std::move(promise_)) {
+    }
+
+    void operator()() override {
+        ask(std::make_index_sequence<std::tuple_size<ArgsTuple>::value>());
+        promise.set_value();
+    }
+
+    template <std::size_t... I>
+    void ask(std::index_sequence<I...>) {
+        (object.*memberFn)(std::move(std::get<I>(argsTuple))...);
+    }
+
+    Object& object;
+    MemberFn memberFn;
+    ArgsTuple argsTuple;
+    std::promise<void> promise;
+};
+
 namespace actor {
 
 template <class Object, class MemberFn, class... Args>
diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 7d6678dc93..5ba23a76dd 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -8,6 +8,7 @@
 #include <mbgl/util/size.hpp>
 #include <mbgl/annotation/annotation.hpp>
 #include <mbgl/map/camera.hpp>
+#include <mbgl/util/geometry.hpp>
 
 #include <cstdint>
 #include <string>
@@ -42,7 +43,8 @@ public:
     // Register a callback that will get called (on the render thread) when all resources have
     // been loaded and a complete render occurs.
     using StillImageCallback = std::function<void (std::exception_ptr)>;
-    void renderStill(StillImageCallback callback);
+    void renderStill(StillImageCallback);
+    void renderStill(const CameraOptions&, MapDebugOptions, StillImageCallback);
 
     // Triggers a repaint.
     void triggerRepaint();
@@ -65,6 +67,10 @@ public:
     void jumpTo(const CameraOptions&);
     void easeTo(const CameraOptions&, const AnimationOptions&);
     void flyTo(const CameraOptions&, const AnimationOptions&);
+    CameraOptions cameraForLatLngBounds(const LatLngBounds&, const EdgeInsets&, optional<double> bearing = {}) const;
+    CameraOptions cameraForLatLngs(const std::vector<LatLng>&, const EdgeInsets&, optional<double> bearing = {}) const;
+    CameraOptions cameraForGeometry(const Geometry<double>&, const EdgeInsets&, optional<double> bearing = {}) const;
+    LatLngBounds latLngBoundsForCamera(const CameraOptions&) const;
 
     // Position
     void moveBy(const ScreenCoordinate&, const AnimationOptions& = {});
@@ -81,9 +87,6 @@ public:
     double getZoom() const;
     void setLatLngZoom(const LatLng&, double zoom, const AnimationOptions& = {});
     void setLatLngZoom(const LatLng&, double zoom, const EdgeInsets&, const AnimationOptions& = {});
-    CameraOptions cameraForLatLngBounds(const LatLngBounds&, const EdgeInsets&) const;
-    CameraOptions cameraForLatLngs(const std::vector<LatLng>&, const EdgeInsets&) const;
-    LatLngBounds latLngBoundsForCamera(const CameraOptions&) const;
     void resetZoom();
 
     // Bounds
@@ -124,6 +127,14 @@ public:
     void setViewportMode(ViewportMode);
     ViewportMode getViewportMode() const;
 
+    // Projection mode
+    void setAxonometric(bool);
+    bool getAxonometric() const;
+    void setXSkew(double ySkew);
+    double getXSkew() const;
+    void setYSkew(double ySkew);
+    double getYSkew() const;
+
     // Size
     void setSize(Size);
     Size getSize() const;
diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp
index 95828a1b79..be8abb2c29 100644
--- a/include/mbgl/renderer/renderer.hpp
+++ b/include/mbgl/renderer/renderer.hpp
@@ -28,6 +28,8 @@ public:
              const optional<std::string> programCacheDir = {});
     ~Renderer();
 
+    void markContextLost();
+
     void setObserver(RendererObserver*);
 
     void render(const UpdateParameters&);
diff --git a/include/mbgl/renderer/renderer_backend.hpp b/include/mbgl/renderer/renderer_backend.hpp
index f7d19a1791..295838c71b 100644
--- a/include/mbgl/renderer/renderer_backend.hpp
+++ b/include/mbgl/renderer/renderer_backend.hpp
@@ -35,6 +35,8 @@ public:
     // set to the current state.
     virtual void bind() = 0;
 
+    virtual Size getFramebufferSize() const = 0;
+
 protected:
     // Called with the name of an OpenGL extension that should be loaded. RendererBackend implementations
     // must call the API-specific version that obtains the function pointer for this function,
diff --git a/include/mbgl/storage/default_file_source.hpp b/include/mbgl/storage/default_file_source.hpp
index 9911e0ce67..b9c8de5052 100644
--- a/include/mbgl/storage/default_file_source.hpp
+++ b/include/mbgl/storage/default_file_source.hpp
@@ -34,7 +34,7 @@ public:
                       uint64_t maximumCacheSize = util::DEFAULT_MAX_CACHE_SIZE);
     ~DefaultFileSource() override;
 
-    bool supportsOptionalRequests() const override {
+    bool supportsCacheOnlyRequests() const override {
         return true;
     }
 
@@ -140,6 +140,7 @@ public:
     void resume();
 
     // For testing only.
+    void setOnlineStatus(bool);
     void put(const Resource&, const Response&);
 
     class Impl;
diff --git a/include/mbgl/storage/file_source.hpp b/include/mbgl/storage/file_source.hpp
index 404c683fdb..0709a1c245 100644
--- a/include/mbgl/storage/file_source.hpp
+++ b/include/mbgl/storage/file_source.hpp
@@ -24,11 +24,11 @@ public:
     // not be executed.
     virtual std::unique_ptr<AsyncRequest> request(const Resource&, Callback) = 0;
 
-    // When a file source supports optional requests, it must return true.
-    // Optional requests are requests that aren't as urgent, but could be useful, e.g.
+    // When a file source supports consulting a local cache only, it must return true.
+    // Cache-only requests are requests that aren't as urgent, but could be useful, e.g.
     // to cover part of the map while loading. The FileSource should only do cheap actions to
     // retrieve the data, e.g. load it from a cache, but not from the internet.
-    virtual bool supportsOptionalRequests() const {
+    virtual bool supportsCacheOnlyRequests() const {
         return false;
     }
 };
diff --git a/include/mbgl/storage/offline.hpp b/include/mbgl/storage/offline.hpp
index 818cfe2ba5..ef4a499e83 100644
--- a/include/mbgl/storage/offline.hpp
+++ b/include/mbgl/storage/offline.hpp
@@ -30,13 +30,15 @@ public:
     OfflineTilePyramidRegionDefinition(std::string, LatLngBounds, double, double, float);
 
     /* Private */
-    std::vector<CanonicalTileID> tileCover(SourceType, uint16_t tileSize, const Range<uint8_t>& zoomRange) const;
-
+    std::vector<CanonicalTileID> tileCover(style::SourceType, uint16_t tileSize, const Range<uint8_t>& zoomRange) const;
+    uint64_t tileCount(style::SourceType, uint16_t tileSize, const Range<uint8_t>& zoomRange) const;
     const std::string styleURL;
     const LatLngBounds bounds;
     const double minZoom;
     const double maxZoom;
     const float pixelRatio;
+private:
+    Range<uint8_t> coveringZoomRange(style::SourceType, uint16_t tileSize, const Range<uint8_t>& zoomRange) const;
 };
 
 /*
diff --git a/include/mbgl/storage/online_file_source.hpp b/include/mbgl/storage/online_file_source.hpp
index ffd75662e6..28d70ce544 100644
--- a/include/mbgl/storage/online_file_source.hpp
+++ b/include/mbgl/storage/online_file_source.hpp
@@ -24,6 +24,9 @@ public:
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
 
+    // For testing only.
+    void setOnlineStatus(bool);
+
 private:
     friend class OnlineFileRequest;
 
diff --git a/include/mbgl/storage/resource.hpp b/include/mbgl/storage/resource.hpp
index 5d44f4869f..318fa389f4 100644
--- a/include/mbgl/storage/resource.hpp
+++ b/include/mbgl/storage/resource.hpp
@@ -4,6 +4,8 @@
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/font_stack.hpp>
 #include <mbgl/util/tileset.hpp>
+#include <mbgl/util/util.hpp>
+#include <mbgl/util/traits.hpp>
 
 #include <string>
 
@@ -30,18 +32,28 @@ public:
         int8_t z;
     };
 
-    enum Necessity : bool {
-        Optional = false,
-        Required = true,
+    enum class LoadingMethod : uint8_t {
+        None        = 0b00,
+        Cache       = 0b01,
+        Network     = 0b10,
+
+        CacheOnly   = Cache,
+        NetworkOnly = Network,
+        All         = Cache | Network,
     };
 
-    Resource(Kind kind_, std::string url_, optional<TileData> tileData_ = {}, Necessity necessity_ = Required)
+    Resource(Kind kind_,
+             std::string url_,
+             optional<TileData> tileData_ = {},
+             LoadingMethod loadingMethod_ = LoadingMethod::All)
         : kind(kind_),
-          necessity(necessity_),
+          loadingMethod(loadingMethod_),
           url(std::move(url_)),
           tileData(std::move(tileData_)) {
     }
 
+    bool hasLoadingMethod(LoadingMethod method);
+
     static Resource style(const std::string& url);
     static Resource source(const std::string& url);
     static Resource tile(const std::string& urlTemplate,
@@ -50,7 +62,7 @@ public:
                          int32_t y,
                          int8_t z,
                          Tileset::Scheme scheme,
-                         Necessity = Required);
+                         LoadingMethod = LoadingMethod::All);
     static Resource glyphs(const std::string& urlTemplate,
                            const FontStack& fontStack,
                            const std::pair<uint16_t, uint16_t>& glyphRange);
@@ -59,7 +71,7 @@ public:
     static Resource image(const std::string& url);
     
     Kind kind;
-    Necessity necessity;
+    LoadingMethod loadingMethod;
     std::string url;
 
     // Includes auxiliary data if this is a tile request.
@@ -71,4 +83,21 @@ public:
     std::shared_ptr<const std::string> priorData;
 };
 
+
+MBGL_CONSTEXPR Resource::LoadingMethod operator|(Resource::LoadingMethod a, Resource::LoadingMethod b) {
+    return Resource::LoadingMethod(mbgl::underlying_type(a) | mbgl::underlying_type(b));
+}
+
+MBGL_CONSTEXPR Resource::LoadingMethod& operator|=(Resource::LoadingMethod& a, Resource::LoadingMethod b) {
+    return (a = a | b);
+}
+
+MBGL_CONSTEXPR Resource::LoadingMethod operator&(Resource::LoadingMethod a, Resource::LoadingMethod b) {
+    return Resource::LoadingMethod(mbgl::underlying_type(a) & mbgl::underlying_type(b));
+}
+
+inline bool Resource::hasLoadingMethod(Resource::LoadingMethod method) {
+    return (loadingMethod & method) != Resource::LoadingMethod::None;
+}
+
 } // namespace mbgl
diff --git a/include/mbgl/storage/response.hpp b/include/mbgl/storage/response.hpp
index 711f008e83..508400141b 100644
--- a/include/mbgl/storage/response.hpp
+++ b/include/mbgl/storage/response.hpp
@@ -2,7 +2,6 @@
 
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/util/optional.hpp>
-#include <mbgl/util/variant.hpp>
 
 #include <string>
 #include <memory>
diff --git a/include/mbgl/style/conversion/geojson_options.hpp b/include/mbgl/style/conversion/geojson_options.hpp
index 19383d90ce..1c9c18250c 100644
--- a/include/mbgl/style/conversion/geojson_options.hpp
+++ b/include/mbgl/style/conversion/geojson_options.hpp
@@ -14,6 +14,16 @@ struct Converter<GeoJSONOptions> {
     optional<GeoJSONOptions> operator()(const V& value, Error& error) const {
         GeoJSONOptions options;
 
+        const auto minzoomValue = objectMember(value, "minzoom");
+        if (minzoomValue) {
+            if (toNumber(*minzoomValue)) {
+                options.minzoom = static_cast<uint8_t>(*toNumber(*minzoomValue));
+            } else {
+                error = { "GeoJSON source minzoom value must be a number" };
+                return {};
+            }
+        }
+
         const auto maxzoomValue = objectMember(value, "maxzoom");
         if (maxzoomValue) {
             if (toNumber(*maxzoomValue)) {
diff --git a/include/mbgl/style/conversion/make_property_setters.hpp b/include/mbgl/style/conversion/make_property_setters.hpp
index 9252297d75..59b0e7be32 100644
--- a/include/mbgl/style/conversion/make_property_setters.hpp
+++ b/include/mbgl/style/conversion/make_property_setters.hpp
@@ -45,17 +45,18 @@ auto makeLayoutPropertySetters() {
     result["icon-padding"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setIconPadding>;
     result["icon-keep-upright"] = &setProperty<V, SymbolLayer, PropertyValue<bool>, &SymbolLayer::setIconKeepUpright>;
     result["icon-offset"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<std::array<float, 2>>, &SymbolLayer::setIconOffset>;
+    result["icon-anchor"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<SymbolAnchorType>, &SymbolLayer::setIconAnchor>;
     result["icon-pitch-alignment"] = &setProperty<V, SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setIconPitchAlignment>;
     result["text-pitch-alignment"] = &setProperty<V, SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setTextPitchAlignment>;
     result["text-rotation-alignment"] = &setProperty<V, SymbolLayer, PropertyValue<AlignmentType>, &SymbolLayer::setTextRotationAlignment>;
     result["text-field"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<std::string>, &SymbolLayer::setTextField>;
     result["text-font"] = &setProperty<V, SymbolLayer, PropertyValue<std::vector<std::string>>, &SymbolLayer::setTextFont>;
     result["text-size"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextSize>;
-    result["text-max-width"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextMaxWidth>;
+    result["text-max-width"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextMaxWidth>;
     result["text-line-height"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextLineHeight>;
-    result["text-letter-spacing"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextLetterSpacing>;
+    result["text-letter-spacing"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextLetterSpacing>;
     result["text-justify"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<TextJustifyType>, &SymbolLayer::setTextJustify>;
-    result["text-anchor"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<TextAnchorType>, &SymbolLayer::setTextAnchor>;
+    result["text-anchor"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<SymbolAnchorType>, &SymbolLayer::setTextAnchor>;
     result["text-max-angle"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextMaxAngle>;
     result["text-rotate"] = &setProperty<V, SymbolLayer, DataDrivenPropertyValue<float>, &SymbolLayer::setTextRotate>;
     result["text-padding"] = &setProperty<V, SymbolLayer, PropertyValue<float>, &SymbolLayer::setTextPadding>;
diff --git a/include/mbgl/style/layers/custom_layer.hpp b/include/mbgl/style/layers/custom_layer.hpp
index 79a353b047..bf3387f95b 100644
--- a/include/mbgl/style/layers/custom_layer.hpp
+++ b/include/mbgl/style/layers/custom_layer.hpp
@@ -39,6 +39,14 @@ struct CustomLayerRenderParameters {
 using CustomLayerRenderFunction = void (*)(void* context, const CustomLayerRenderParameters&);
 
 /**
+ * Called when the system has destroyed the underlying GL context. The
+ * `CustomLayerDeinitializeFunction` will not be called in this case, however
+ * `CustomLayerInitializeFunction` will be called instead to prepare for a new render.
+ *
+ */
+using CustomLayerContextLostFunction = void (*)(void* context);
+
+/**
  * Destroy any GL state needed by the custom layer, and deallocate context, if necessary. This
  * method is called once, from the main thread, at a point when the GL context is active.
  *
@@ -51,8 +59,16 @@ public:
     CustomLayer(const std::string& id,
                 CustomLayerInitializeFunction,
                 CustomLayerRenderFunction,
+                CustomLayerContextLostFunction,
                 CustomLayerDeinitializeFunction,
                 void* context);
+
+    CustomLayer(const std::string& id,
+                CustomLayerInitializeFunction,
+                CustomLayerRenderFunction,
+                CustomLayerDeinitializeFunction,
+                void* context);
+
     ~CustomLayer() final;
 
     // Visibility
diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp
index 6e355c0057..a72baa0b4e 100644
--- a/include/mbgl/style/layers/symbol_layer.hpp
+++ b/include/mbgl/style/layers/symbol_layer.hpp
@@ -98,6 +98,10 @@ public:
     DataDrivenPropertyValue<std::array<float, 2>> getIconOffset() const;
     void setIconOffset(DataDrivenPropertyValue<std::array<float, 2>>);
 
+    static DataDrivenPropertyValue<SymbolAnchorType> getDefaultIconAnchor();
+    DataDrivenPropertyValue<SymbolAnchorType> getIconAnchor() const;
+    void setIconAnchor(DataDrivenPropertyValue<SymbolAnchorType>);
+
     static PropertyValue<AlignmentType> getDefaultIconPitchAlignment();
     PropertyValue<AlignmentType> getIconPitchAlignment() const;
     void setIconPitchAlignment(PropertyValue<AlignmentType>);
@@ -122,25 +126,25 @@ public:
     DataDrivenPropertyValue<float> getTextSize() const;
     void setTextSize(DataDrivenPropertyValue<float>);
 
-    static PropertyValue<float> getDefaultTextMaxWidth();
-    PropertyValue<float> getTextMaxWidth() const;
-    void setTextMaxWidth(PropertyValue<float>);
+    static DataDrivenPropertyValue<float> getDefaultTextMaxWidth();
+    DataDrivenPropertyValue<float> getTextMaxWidth() const;
+    void setTextMaxWidth(DataDrivenPropertyValue<float>);
 
     static PropertyValue<float> getDefaultTextLineHeight();
     PropertyValue<float> getTextLineHeight() const;
     void setTextLineHeight(PropertyValue<float>);
 
-    static PropertyValue<float> getDefaultTextLetterSpacing();
-    PropertyValue<float> getTextLetterSpacing() const;
-    void setTextLetterSpacing(PropertyValue<float>);
+    static DataDrivenPropertyValue<float> getDefaultTextLetterSpacing();
+    DataDrivenPropertyValue<float> getTextLetterSpacing() const;
+    void setTextLetterSpacing(DataDrivenPropertyValue<float>);
 
     static DataDrivenPropertyValue<TextJustifyType> getDefaultTextJustify();
     DataDrivenPropertyValue<TextJustifyType> getTextJustify() const;
     void setTextJustify(DataDrivenPropertyValue<TextJustifyType>);
 
-    static DataDrivenPropertyValue<TextAnchorType> getDefaultTextAnchor();
-    DataDrivenPropertyValue<TextAnchorType> getTextAnchor() const;
-    void setTextAnchor(DataDrivenPropertyValue<TextAnchorType>);
+    static DataDrivenPropertyValue<SymbolAnchorType> getDefaultTextAnchor();
+    DataDrivenPropertyValue<SymbolAnchorType> getTextAnchor() const;
+    void setTextAnchor(DataDrivenPropertyValue<SymbolAnchorType>);
 
     static PropertyValue<float> getDefaultTextMaxAngle();
     PropertyValue<float> getTextMaxAngle() const;
diff --git a/include/mbgl/style/sources/geojson_source.hpp b/include/mbgl/style/sources/geojson_source.hpp
index 2dcfec51aa..5bdf1ef957 100644
--- a/include/mbgl/style/sources/geojson_source.hpp
+++ b/include/mbgl/style/sources/geojson_source.hpp
@@ -12,6 +12,7 @@ namespace style {
 
 struct GeoJSONOptions {
     // GeoJSON-VT options
+    uint8_t minzoom = 0;
     uint8_t maxzoom = 18;
     uint16_t buffer = 128;
     double tolerance = 0.375;
diff --git a/include/mbgl/style/types.hpp b/include/mbgl/style/types.hpp
index 44b16f16e7..2ed95f08b8 100644
--- a/include/mbgl/style/types.hpp
+++ b/include/mbgl/style/types.hpp
@@ -4,7 +4,9 @@
 
 namespace mbgl {
 
-// TODO: should be in public source.hpp header and style namespace
+namespace style {
+
+// TODO: should be in public source.hpp header
 enum class SourceType : uint8_t {
     Vector,
     Raster,
@@ -14,8 +16,6 @@ enum class SourceType : uint8_t {
     Image
 };
 
-namespace style {
-
 enum class VisibilityType : bool {
     Visible,
     None,
@@ -68,7 +68,7 @@ enum class TextJustifyType : uint8_t {
     Right
 };
 
-enum class TextAnchorType : uint8_t {
+enum class SymbolAnchorType : uint8_t {
     Center,
     Left,
     Right,
diff --git a/include/mbgl/tile/tile_id.hpp b/include/mbgl/tile/tile_id.hpp
new file mode 100644
index 0000000000..0457dd3a07
--- /dev/null
+++ b/include/mbgl/tile/tile_id.hpp
@@ -0,0 +1,263 @@
+#pragma once
+
+#include <mbgl/util/constants.hpp>
+
+#include <cstdint>
+#include <array>
+#include <tuple>
+#include <forward_list>
+#include <algorithm>
+#include <iosfwd>
+#include <cassert>
+
+namespace mbgl {
+
+class OverscaledTileID;
+class CanonicalTileID;
+class UnwrappedTileID;
+
+// Has integer z/x/y coordinates
+// All tiles must be derived from 0/0/0 (=no tiles outside of the main tile pyramid)
+// Used for requesting data; represents data tiles that exist out there.
+// z is never larger than the source's maxzoom
+class CanonicalTileID {
+public:
+    CanonicalTileID(uint8_t z, uint32_t x, uint32_t y);
+    bool operator==(const CanonicalTileID&) const;
+    bool operator!=(const CanonicalTileID&) const;
+    bool operator<(const CanonicalTileID&) const;
+    bool isChildOf(const CanonicalTileID&) const;
+    CanonicalTileID scaledTo(uint8_t z) const;
+    std::array<CanonicalTileID, 4> children() const;
+
+    const uint8_t z;
+    const uint32_t x;
+    const uint32_t y;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const CanonicalTileID& rhs);
+namespace util {
+std::string toString(const CanonicalTileID&);
+} // namespace util
+
+// Has integer z/x/y coordinates
+// overscaledZ describes the zoom level this tile is intented to represent, e.g. when parsing data
+// z is never larger than the source's maxzoom
+// z/x/y describe the
+class OverscaledTileID {
+public:
+    OverscaledTileID(uint8_t overscaledZ, int16_t wrap, CanonicalTileID);
+    OverscaledTileID(uint8_t overscaledZ, int16_t wrap, uint8_t z, uint32_t x, uint32_t y);
+    OverscaledTileID(uint8_t z, uint32_t x, uint32_t y);
+    explicit OverscaledTileID(const CanonicalTileID&);
+    explicit OverscaledTileID(CanonicalTileID&&);
+    bool operator==(const OverscaledTileID&) const;
+    bool operator!=(const OverscaledTileID&) const;
+    bool operator<(const OverscaledTileID&) const;
+    bool isChildOf(const OverscaledTileID&) const;
+    uint32_t overscaleFactor() const;
+    OverscaledTileID scaledTo(uint8_t z) const;
+    UnwrappedTileID toUnwrapped() const;
+
+    const uint8_t overscaledZ;
+    const int16_t wrap;
+    const CanonicalTileID canonical;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const OverscaledTileID& rhs);
+namespace util {
+std::string toString(const OverscaledTileID&);
+} // namespace util
+
+// Has integer z/x/y coordinates
+// wrap describes tiles that are left/right of the main tile pyramid, e.g. when wrapping the world
+// Used for describing what position tiles are getting rendered at (= calc the matrix)
+// z is never larger than the source's maxzoom
+class UnwrappedTileID {
+public:
+    UnwrappedTileID(uint8_t z, int64_t x, int64_t y);
+    UnwrappedTileID(int16_t wrap, CanonicalTileID);
+    bool operator==(const UnwrappedTileID&) const;
+    bool operator!=(const UnwrappedTileID&) const;
+    bool operator<(const UnwrappedTileID&) const;
+    bool isChildOf(const UnwrappedTileID&) const;
+    std::array<UnwrappedTileID, 4> children() const;
+    OverscaledTileID overscaleTo(uint8_t z) const;
+    float pixelsToTileUnits(float pixelValue, float zoom) const;
+
+    const int16_t wrap;
+    const CanonicalTileID canonical;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const UnwrappedTileID& rhs);
+namespace util {
+std::string toString(const UnwrappedTileID&);
+} // namespace util
+
+inline CanonicalTileID::CanonicalTileID(uint8_t z_, uint32_t x_, uint32_t y_) : z(z_), x(x_), y(y_) {
+    assert(z <= 32);
+    assert(x < (1ull << z));
+    assert(y < (1ull << z));
+}
+
+inline bool CanonicalTileID::operator==(const CanonicalTileID& rhs) const {
+    return z == rhs.z && x == rhs.x && y == rhs.y;
+}
+
+inline bool CanonicalTileID::operator!=(const CanonicalTileID& rhs) const {
+    return z != rhs.z || x != rhs.x || y != rhs.y;
+}
+
+inline bool CanonicalTileID::operator<(const CanonicalTileID& rhs) const {
+    return std::tie(z, x, y) < std::tie(rhs.z, rhs.x, rhs.y);
+}
+
+inline bool CanonicalTileID::isChildOf(const CanonicalTileID& parent) const {
+    // We're first testing for z == 0, to avoid a 32 bit shift, which is undefined.
+    return parent.z == 0 ||
+           (parent.z < z && parent.x == (x >> (z - parent.z)) && parent.y == (y >> (z - parent.z)));
+}
+
+inline CanonicalTileID CanonicalTileID::scaledTo(uint8_t targetZ) const {
+    if (targetZ <= z) {
+        return { targetZ, x >> (z - targetZ), y >> (z - targetZ) }; // parent or same
+    } else {
+        return { targetZ, x << (targetZ - z), y << (targetZ - z) }; // child
+    }
+}
+
+inline std::array<CanonicalTileID, 4> CanonicalTileID::children() const {
+    const uint8_t childZ = z + 1;
+    const uint32_t childX = x * 2;
+    const uint32_t childY = y * 2;
+    return { {
+        { childZ, childX, childY },
+        { childZ, childX, childY + 1 },
+        { childZ, childX + 1, childY },
+        { childZ, childX + 1, childY + 1 },
+    } };
+}
+
+inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, int16_t wrap_, CanonicalTileID canonical_)
+    : overscaledZ(overscaledZ_), wrap(wrap_), canonical(std::move(canonical_)) {
+    assert(overscaledZ >= canonical.z);
+}
+
+inline OverscaledTileID::OverscaledTileID(uint8_t overscaledZ_, int16_t wrap_, uint8_t z, uint32_t x, uint32_t y)
+    : overscaledZ(overscaledZ_), wrap(wrap_), canonical(z, x, y) {
+    assert(overscaledZ >= canonical.z);
+}
+
+inline OverscaledTileID::OverscaledTileID(uint8_t z, uint32_t x, uint32_t y)
+    : overscaledZ(z), wrap(0), canonical(z, x, y) {
+}
+
+inline OverscaledTileID::OverscaledTileID(const CanonicalTileID& canonical_)
+    : overscaledZ(canonical_.z), wrap(0), canonical(canonical_) {
+    assert(overscaledZ >= canonical.z);
+}
+
+inline OverscaledTileID::OverscaledTileID(CanonicalTileID&& canonical_)
+    : overscaledZ(canonical_.z), wrap(0), canonical(std::forward<CanonicalTileID>(canonical_)) {
+    assert(overscaledZ >= canonical.z);
+}
+
+inline bool OverscaledTileID::operator==(const OverscaledTileID& rhs) const {
+    return overscaledZ == rhs.overscaledZ && wrap == rhs.wrap &&canonical == rhs.canonical;
+}
+
+inline bool OverscaledTileID::operator!=(const OverscaledTileID& rhs) const {
+    return overscaledZ != rhs.overscaledZ || wrap != rhs.wrap || canonical != rhs.canonical;
+}
+
+inline bool OverscaledTileID::operator<(const OverscaledTileID& rhs) const {
+    return std::tie(overscaledZ, wrap, canonical) < std::tie(rhs.overscaledZ, rhs.wrap, rhs.canonical);
+}
+
+inline uint32_t OverscaledTileID::overscaleFactor() const {
+    return 1u << (overscaledZ - canonical.z);
+}
+
+inline bool OverscaledTileID::isChildOf(const OverscaledTileID& rhs) const {
+    return overscaledZ > rhs.overscaledZ &&
+           (canonical == rhs.canonical || canonical.isChildOf(rhs.canonical));
+}
+
+inline OverscaledTileID OverscaledTileID::scaledTo(uint8_t z) const {
+    return { z, wrap, z >= canonical.z ? canonical : canonical.scaledTo(z) };
+}
+
+inline UnwrappedTileID OverscaledTileID::toUnwrapped() const {
+    return { wrap, canonical };
+}
+
+inline UnwrappedTileID::UnwrappedTileID(uint8_t z_, int64_t x_, int64_t y_)
+    : wrap((x_ < 0 ? x_ - (1ll << z_) + 1 : x_) / (1ll << z_)),
+      canonical(
+          z_,
+          static_cast<uint32_t>(x_ - wrap * (1ll << z_)),
+          y_ < 0 ? 0 : std::min(static_cast<uint32_t>(y_), static_cast<uint32_t>(1ull << z_) - 1)) {
+}
+
+inline UnwrappedTileID::UnwrappedTileID(int16_t wrap_, CanonicalTileID canonical_)
+    : wrap(wrap_), canonical(std::move(canonical_)) {
+}
+
+inline bool UnwrappedTileID::operator==(const UnwrappedTileID& rhs) const {
+    return wrap == rhs.wrap && canonical == rhs.canonical;
+}
+
+inline bool UnwrappedTileID::operator!=(const UnwrappedTileID& rhs) const {
+    return wrap != rhs.wrap || canonical != rhs.canonical;
+}
+
+inline bool UnwrappedTileID::operator<(const UnwrappedTileID& rhs) const {
+    return std::tie(wrap, canonical) < std::tie(rhs.wrap, rhs.canonical);
+}
+
+inline bool UnwrappedTileID::isChildOf(const UnwrappedTileID& parent) const {
+    return wrap == parent.wrap && canonical.isChildOf(parent.canonical);
+}
+
+inline std::array<UnwrappedTileID, 4> UnwrappedTileID::children() const {
+    const uint8_t childZ = canonical.z + 1;
+    const uint32_t childX = canonical.x * 2;
+    const uint32_t childY = canonical.y * 2;
+    return { {
+        { wrap, { childZ, childX, childY } },
+        { wrap, { childZ, childX, childY + 1 } },
+        { wrap, { childZ, childX + 1, childY } },
+        { wrap, { childZ, childX + 1, childY + 1 } },
+    } };
+}
+
+inline OverscaledTileID UnwrappedTileID::overscaleTo(const uint8_t overscaledZ) const {
+    assert(overscaledZ >= canonical.z);
+    return { overscaledZ, wrap, canonical };
+}
+
+inline float UnwrappedTileID::pixelsToTileUnits(const float pixelValue, const float zoom) const {
+    return pixelValue * (util::EXTENT / (util::tileSize * std::pow(2, zoom - canonical.z)));
+}
+
+} // namespace mbgl
+
+namespace std {
+
+template <>
+struct hash<mbgl::CanonicalTileID> {
+    size_t operator()(const mbgl::CanonicalTileID& id) const;
+};
+
+template <>
+struct hash<mbgl::UnwrappedTileID> {
+    size_t operator()(const mbgl::UnwrappedTileID& id) const;
+};
+
+template <>
+struct hash<mbgl::OverscaledTileID> {
+    size_t operator()(const mbgl::OverscaledTileID& id) const;
+};
+
+} // namespace std
+
diff --git a/include/mbgl/tile/tile_necessity.hpp b/include/mbgl/tile/tile_necessity.hpp
new file mode 100644
index 0000000000..e51bf51d10
--- /dev/null
+++ b/include/mbgl/tile/tile_necessity.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace mbgl {
+
+// Tiles can have two states: optional or required.
+// - optional means that only low-cost actions should be taken to obtain the data
+//   (e.g. load from cache, but accept stale data)
+// - required means that every effort should be taken to obtain the data (e.g. load
+//   from internet and keep the data fresh if it expires)
+enum class TileNecessity : bool {
+    Optional = false,
+    Required = true,
+};
+
+} // namespace mbgl
diff --git a/include/mbgl/util/constants.hpp b/include/mbgl/util/constants.hpp
index eb5c201793..d5e55065c4 100644
--- a/include/mbgl/util/constants.hpp
+++ b/include/mbgl/util/constants.hpp
@@ -61,7 +61,6 @@ extern const bool tileParseWarnings;
 extern const bool styleParseWarnings;
 extern const bool spriteWarnings;
 extern const bool renderWarnings;
-extern const bool renderTree;
 extern const bool labelTextMissingWarning;
 extern const bool missingFontStackWarning;
 extern const bool missingFontFaceWarning;
diff --git a/include/mbgl/util/geometry.hpp b/include/mbgl/util/geometry.hpp
index 6dc16bc514..a28c59a47d 100644
--- a/include/mbgl/util/geometry.hpp
+++ b/include/mbgl/util/geometry.hpp
@@ -2,6 +2,7 @@
 
 #include <mapbox/geometry/geometry.hpp>
 #include <mapbox/geometry/point_arithmetic.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
 
 namespace mbgl {
 
@@ -58,4 +59,9 @@ struct ToFeatureType {
     FeatureType operator()(const mapbox::geometry::geometry_collection<T> &) const { return FeatureType::Unknown; }
 };
 
+template <class T, typename F>
+auto forEachPoint(const Geometry<T>& g, F f) {
+    mapbox::geometry::for_each_point(g, f);
+}
+
 } // namespace mbgl
diff --git a/include/mbgl/util/image.hpp b/include/mbgl/util/image.hpp
index cb28f3da8d..4887058f79 100644
--- a/include/mbgl/util/image.hpp
+++ b/include/mbgl/util/image.hpp
@@ -5,6 +5,7 @@
 #include <mbgl/util/size.hpp>
 
 #include <string>
+#include <cstring>
 #include <memory>
 #include <algorithm>
 
@@ -91,6 +92,31 @@ public:
         operator=(std::move(newImage));
     }
 
+    // Clears the rect area specified by `pt` and `size` from `dstImage`.
+    static void clear(Image& dstImg, const Point<uint32_t>& pt, const Size& size) {
+        if (size.isEmpty()) {
+            return;
+        }
+
+        if (!dstImg.valid()) {
+            throw std::invalid_argument("invalid destination for image clear");
+        }
+
+        if (size.width > dstImg.size.width ||
+            size.height > dstImg.size.height ||
+            pt.x > dstImg.size.width - size.width ||
+            pt.y > dstImg.size.height - size.height) {
+            throw std::out_of_range("out of range destination coordinates for image clear");
+        }
+
+        uint8_t* dstData = dstImg.data.get();
+
+        for (uint32_t y = 0; y < size.height; y++) {
+            const std::size_t dstOffset = (pt.y + y) * dstImg.stride() + pt.x * channels;
+            std::memset(dstData + dstOffset, 0, size.width * channels);
+        }
+    }
+
     // Copy image data within `rect` from `src` to the rectangle of the same size at `pt`
     // in `dst`. If the specified bounds exceed the bounds of the source or destination,
     // throw `std::out_of_range`. Must not be used to move data within a single Image.
diff --git a/include/mbgl/util/projection.hpp b/include/mbgl/util/projection.hpp
index 3cc1146513..f64502c5bc 100644
--- a/include/mbgl/util/projection.hpp
+++ b/include/mbgl/util/projection.hpp
@@ -75,10 +75,7 @@ public:
     }
 
     static Point<double> project(const LatLng& latLng, double scale) {
-        return Point<double> {
-            util::LONGITUDE_MAX + latLng.longitude(),
-            util::LONGITUDE_MAX - util::RAD2DEG * std::log(std::tan(M_PI / 4 + latLng.latitude() * M_PI / util::DEGREES_MAX))
-        } * worldSize(scale) / util::DEGREES_MAX;
+        return project_(latLng, worldSize(scale));
     }
 
     static LatLng unproject(const Point<double>& p, double scale, LatLng::WrapMode wrapMode = LatLng::Unwrapped) {
@@ -89,6 +86,23 @@ public:
             wrapMode
         };
     }
+    
+    // Project lat, lon to point in a zoom-dependent world size
+    static Point<double> project(const LatLng& point, uint8_t zoom, uint16_t tileSize) {
+        const double t2z = tileSize * std::pow(2, zoom);
+        Point<double> pt = project_(point, t2z);
+        // Flip y coordinate
+        auto x = std::round(std::min(pt.x, t2z));
+        auto y = std::round(std::min(t2z - pt.y, t2z));
+        return { x, y };
+    }
+private:
+    static Point<double> project_(const LatLng& latLng, double worldSize) {
+        return Point<double> {
+            util::LONGITUDE_MAX + latLng.longitude(),
+            util::LONGITUDE_MAX - util::RAD2DEG * std::log(std::tan(M_PI / 4 + latLng.latitude() * M_PI / util::DEGREES_MAX))
+        } * worldSize / util::DEGREES_MAX;
+    }
 };
 
 } // namespace mbgl
diff --git a/include/mbgl/util/thread.hpp b/include/mbgl/util/thread.hpp
new file mode 100644
index 0000000000..672eebf6db
--- /dev/null
+++ b/include/mbgl/util/thread.hpp
@@ -0,0 +1,161 @@
+#pragma once
+
+#include <mbgl/actor/actor.hpp>
+#include <mbgl/actor/mailbox.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/util/platform.hpp>
+#include <mbgl/util/run_loop.hpp>
+#include <mbgl/util/util.hpp>
+
+#include <cassert>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace mbgl {
+namespace util {
+
+// Manages a thread with `Object`.
+
+// Upon creation of this object, it launches a thread and creates an object of type `Object`
+// in that thread. When the `Thread<>` object is destructed, the destructor waits
+// for thread termination. The `Thread<>` constructor blocks until the thread and
+// the `Object` are fully created, so after the object creation, it's safe to obtain the
+// `Object` stored in this thread. The thread created will always have low priority on
+// the platforms that support setting thread priority.
+//
+// The following properties make this class different from `ThreadPool`:
+//
+// - Only one thread is created.
+// - `Object` will live in a single thread, providing thread affinity.
+// - It is safe to use `ThreadLocal` in an `Object` managed by `Thread<>`
+// - A `RunLoop` is created for the `Object` thread.
+// - `Object` can use `Timer` and do asynchronous I/O, like wait for sockets events.
+//
+template<class Object>
+class Thread : public Scheduler {
+public:
+    template <class... Args>
+    Thread(const std::string& name, Args&&... args) {
+        std::promise<void> running;
+
+        thread = std::thread([&] {
+            platform::setCurrentThreadName(name);
+            platform::makeThreadLowPriority();
+
+            util::RunLoop loop_(util::RunLoop::Type::New);
+            loop = &loop_;
+
+            object = std::make_unique<Actor<Object>>(*this, std::forward<Args>(args)...);
+            running.set_value();
+
+            loop->run();
+            loop = nullptr;
+        });
+
+        running.get_future().get();
+    }
+
+    ~Thread() override {
+        if (paused) {
+            resume();
+        }
+
+        std::promise<void> joinable;
+
+        // Kill the actor, so we don't get more
+        // messages posted on this scheduler after
+        // we delete the RunLoop.
+        loop->invoke([&] {
+            object.reset();
+            joinable.set_value();
+        });
+
+        joinable.get_future().get();
+
+        loop->stop();
+        thread.join();
+    }
+
+    // Returns a non-owning reference to `Object` that
+    // can be used to send messages to `Object`. It is safe
+    // to the non-owning reference to outlive this object
+    // and be used after the `Thread<>` gets destroyed.
+    ActorRef<std::decay_t<Object>> actor() const {
+        return object->self();
+    }
+
+    // Pauses the `Object` thread. It will prevent the object to wake
+    // up from events such as timers and file descriptor I/O. Messages
+    // sent to a paused `Object` will be queued and only processed after
+    // `resume()` is called.
+    void pause() {
+        MBGL_VERIFY_THREAD(tid);
+
+        assert(!paused);
+
+        paused = std::make_unique<std::promise<void>>();
+        resumed = std::make_unique<std::promise<void>>();
+
+        auto pausing = paused->get_future();
+
+        loop->invoke([this] {
+            auto resuming = resumed->get_future();
+            paused->set_value();
+            resuming.get();
+        });
+
+        pausing.get();
+    }
+
+    // Resumes the `Object` thread previously paused by `pause()`.
+    void resume() {
+        MBGL_VERIFY_THREAD(tid);
+
+        assert(paused);
+
+        resumed->set_value();
+
+        resumed.reset();
+        paused.reset();
+    }
+
+private:
+    MBGL_STORE_THREAD(tid);
+
+    void schedule(std::weak_ptr<Mailbox> mailbox) override {
+        {
+            std::lock_guard<std::mutex> lock(mutex);
+            queue.push(mailbox);
+        }
+
+        loop->invoke([this] { receive(); });
+    }
+
+    void receive() {
+        std::unique_lock<std::mutex> lock(mutex);
+
+        auto mailbox = queue.front();
+        queue.pop();
+        lock.unlock();
+
+        Mailbox::maybeReceive(mailbox);
+    }
+
+    std::mutex mutex;
+    std::queue<std::weak_ptr<Mailbox>> queue;
+    std::thread thread;
+    std::unique_ptr<Actor<Object>> object;
+
+    std::unique_ptr<std::promise<void>> paused;
+    std::unique_ptr<std::promise<void>> resumed;
+
+    util::RunLoop* loop = nullptr;
+};
+
+} // namespace util
+} // namespace mbgl