Bump Mapbox GL Native

mapbox-gl-native @ 5de373fff0e71496b6aa11ecb6556f958a28d80b

12 files changed, 289 insertions, 60 deletions

diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
index 111f0234ed..057ad5a4a7 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
@@ -44,6 +44,7 @@ void RenderCustomGeometrySource::update(Immutable<style::Source::Impl> baseImpl_
                        SourceType::CustomVector,
                        util::tileSize,
                        impl().getZoomRange(),
+                       {},
                        [&] (const OverscaledTileID& tileID) {
                            return std::make_unique<CustomGeometryTile>(tileID, impl().id, parameters, impl().getTileOptions(), *tileLoader);
                        });
@@ -75,8 +76,8 @@ std::vector<Feature> RenderCustomGeometrySource::querySourceFeatures(const Sourc
     return tilePyramid.querySourceFeatures(options);
 }
 
-void RenderCustomGeometrySource::onLowMemory() {
-    tilePyramid.onLowMemory();
+void RenderCustomGeometrySource::reduceMemoryUse() {
+    tilePyramid.reduceMemoryUse();
 }
 
 void RenderCustomGeometrySource::dumpDebugLogs() const {
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
index 82e691d5c9..033d731029 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
@@ -33,7 +33,7 @@ public:
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void onLowMemory() final;
+    void reduceMemoryUse() final;
     void dumpDebugLogs() const final;
     
 private:
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index d07cfcdc41..cbf4db70b5 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -62,6 +62,7 @@ void RenderGeoJSONSource::update(Immutable<style::Source::Impl> baseImpl_,
                        SourceType::GeoJSON,
                        util::tileSize,
                        impl().getZoomRange(),
+                       optional<LatLngBounds>{},
                        [&] (const OverscaledTileID& tileID) {
                            return std::make_unique<GeoJSONTile>(tileID, impl().id, parameters, data->getTile(tileID.canonical));
                        });
@@ -93,8 +94,8 @@ std::vector<Feature> RenderGeoJSONSource::querySourceFeatures(const SourceQueryO
     return tilePyramid.querySourceFeatures(options);
 }
 
-void RenderGeoJSONSource::onLowMemory() {
-    tilePyramid.onLowMemory();
+void RenderGeoJSONSource::reduceMemoryUse() {
+    tilePyramid.reduceMemoryUse();
 }
 
 void RenderGeoJSONSource::dumpDebugLogs() const {
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index 55166ea901..72fccbd043 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -37,7 +37,7 @@ public:
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void onLowMemory() final;
+    void reduceMemoryUse() final;
     void dumpDebugLogs() const final;
 
 private:
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index b5c42584e0..31a5916a34 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -41,7 +41,7 @@ void RenderImageSource::startRender(PaintParameters& parameters) {
         mat4 matrix;
         matrix::identity(matrix);
         parameters.state.matrixFor(matrix, tileIds[i]);
-        matrix::multiply(matrix, parameters.projMatrix, matrix);
+        matrix::multiply(matrix, parameters.alignedProjMatrix, matrix);
         matrices.push_back(matrix);
     }
 
@@ -56,7 +56,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
     }
 
     static const style::Properties<>::PossiblyEvaluated properties {};
-    static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
+    static const DebugProgram::PaintPropertyBinders paintAttributeData(properties, 0);
 
     for (auto matrix : matrices) {
         parameters.programs.debug.draw(
@@ -72,7 +72,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
             parameters.staticData.tileVertexBuffer,
             parameters.staticData.tileBorderIndexBuffer,
             parameters.staticData.tileBorderSegments,
-            paintAttibuteData,
+            paintAttributeData,
             properties,
             parameters.state.getZoom(),
             "debug"
@@ -114,44 +114,43 @@ void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
         return;
     }
 
-    auto size = transformState.getSize();
-    const double viewportHeight = size.height;
-
-    // Compute the screen coordinates at wrap=0 for the given LatLng
-    ScreenCoordinate nePixel = { -INFINITY, -INFINITY };
-    ScreenCoordinate swPixel = { INFINITY, INFINITY };
-
+    // Compute the z0 tile coordinates for the given LatLngs
+    TileCoordinatePoint nePoint = { -INFINITY, -INFINITY };
+    TileCoordinatePoint swPoint = { INFINITY, INFINITY };
+    std::vector<TileCoordinatePoint> tileCoordinates;
     for (LatLng latLng : coords) {
-        ScreenCoordinate pixel = transformState.latLngToScreenCoordinate(latLng);
-        swPixel.x = std::min(swPixel.x, pixel.x);
-        nePixel.x = std::max(nePixel.x, pixel.x);
-        swPixel.y = std::min(swPixel.y, viewportHeight - pixel.y);
-        nePixel.y = std::max(nePixel.y, viewportHeight - pixel.y);
-    }
-    const double width = nePixel.x - swPixel.x;
-    const double height = nePixel.y - swPixel.y;
+        auto point = TileCoordinate::fromLatLng(0, latLng).p;
+        tileCoordinates.push_back(point);
+        swPoint.x = std::min(swPoint.x, point.x);
+        nePoint.x = std::max(nePoint.x, point.x);
+        swPoint.y = std::min(swPoint.y, point.y);
+        nePoint.y = std::max(nePoint.y, point.y);
+   }
 
-    // Don't bother drawing the ImageSource unless it occupies >4 screen pixels
-    enabled = (width * height > 4);
+    // Calculate the optimum zoom level to determine the tile ids to use for transforms
+    auto dx = nePoint.x - swPoint.x;
+    auto dy = nePoint.y - swPoint.y;
+    auto dMax = std::max(dx, dy);
+    double zoom = std::max(0.0, std::floor(-util::log2(dMax)));
+
+    // Only enable if the long side of the image is > 2 pixels. Resulting in a
+    // display of at least 2 x 1 px image
+    // A tile coordinate unit represents the length of one tile (tileSize) at a given zoom.
+    // To convert a tile coordinate to pixels, multiply by tileSize.
+    // Here dMax is in z0 tile units, so we also scale by 2^z to match current zoom.
+    enabled = dMax * std::pow(2.0, transformState.getZoom()) * util::tileSize > 2.0;
     if (!enabled) {
         return;
     }
 
-    // Calculate the optimum zoom level to determine the tile ids to use for transforms
-    double minScale = INFINITY;
-    double scaleX = double(size.width) / width;
-    double scaleY = double(size.height) / height;
-    minScale = util::min(scaleX, scaleY);
-    double zoom = transformState.getZoom() + util::log2(minScale);
-    zoom = std::floor(util::clamp(zoom, transformState.getMinZoom(), transformState.getMaxZoom()));
     auto imageBounds = LatLngBounds::hull(coords[0], coords[1]);
     imageBounds.extend(coords[2]);
     imageBounds.extend(coords[3]);
     auto tileCover = util::tileCover(imageBounds, zoom);
     tileIds.clear();
     tileIds.push_back(tileCover[0]);
-    bool hasVisibleTile = false;
 
+    bool hasVisibleTile = false;
     // Add additional wrapped tile ids if neccessary
     auto idealTiles = util::tileCover(transformState, transformState.getZoom());
     for (auto tile : idealTiles) {
@@ -177,9 +176,8 @@ void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
 
     // Calculate Geometry Coordinates based on tile cover at ideal zoom
     GeometryCoordinates geomCoords;
-    for (auto latLng : coords) {
-        auto tc = TileCoordinate::fromLatLng(0, latLng);
-        auto gc = TileCoordinate::toGeometryCoordinate(tileIds[0], tc.p);
+    for (auto tileCoords : tileCoordinates) {
+        auto gc = TileCoordinate::toGeometryCoordinate(tileIds[0], tileCoords);
         geomCoords.push_back(gc);
     }
     if (!bucket) {
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index 72cf4cea61..85ee0ace11 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -37,7 +37,7 @@ public:
 
     std::vector<Feature> querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void onLowMemory() final {
+    void reduceMemoryUse() final {
     }
     void dumpDebugLogs() const final;
 
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.cpp b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
new file mode 100644
index 0000000000..b3153622c3
--- /dev/null
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
@@ -0,0 +1,166 @@
+#include <mbgl/renderer/sources/render_raster_dem_source.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/tile/raster_dem_tile.hpp>
+#include <mbgl/algorithm/update_tile_masks.hpp>
+#include <mbgl/geometry/dem_data.hpp>
+#include <mbgl/renderer/buckets/hillshade_bucket.hpp>
+#include <iostream>
+
+namespace mbgl {
+
+using namespace style;
+
+RenderRasterDEMSource::RenderRasterDEMSource(Immutable<style::RasterSource::Impl> impl_)
+    : RenderSource(impl_) {
+    tilePyramid.setObserver(this);
+}
+
+const style::RasterSource::Impl& RenderRasterDEMSource::impl() const {
+    return static_cast<const style::RasterSource::Impl&>(*baseImpl);
+}
+
+bool RenderRasterDEMSource::isLoaded() const {
+    return tilePyramid.isLoaded();
+}
+
+void RenderRasterDEMSource::update(Immutable<style::Source::Impl> baseImpl_,
+                                const std::vector<Immutable<Layer::Impl>>& layers,
+                                const bool needsRendering,
+                                const bool needsRelayout,
+                                const TileParameters& parameters) {
+    std::swap(baseImpl, baseImpl_);
+
+    enabled = needsRendering;
+
+    optional<Tileset> _tileset = impl().getTileset();
+
+    if (tileset != _tileset) {
+        tileset = _tileset;
+        maxzoom = tileset->zoomRange.max;
+        // TODO: this removes existing buckets, and will cause flickering.
+        // Should instead refresh tile data in place.
+        tilePyramid.tiles.clear();
+        tilePyramid.renderTiles.clear();
+        tilePyramid.cache.clear();
+    }
+    // Allow clearing the tile pyramid first, before the early return in case
+    //  the new tileset is not yet available or has an error in loading
+    if (!_tileset) {
+        return;
+    }
+
+    tilePyramid.update(layers,
+                       needsRendering,
+                       needsRelayout,
+                       parameters,
+                       SourceType::RasterDEM,
+                       impl().getTileSize(),
+                       tileset->zoomRange,
+                       tileset->bounds,
+                       [&] (const OverscaledTileID& tileID) {
+                           return std::make_unique<RasterDEMTile>(tileID, parameters, *tileset);
+                       });
+}
+
+void RenderRasterDEMSource::onTileChanged(Tile& tile){
+    RasterDEMTile& demtile = static_cast<RasterDEMTile&>(tile);
+
+    std::map<DEMTileNeighbors, DEMTileNeighbors> opposites = {
+        { DEMTileNeighbors::Left, DEMTileNeighbors::Right },
+        { DEMTileNeighbors::Right, DEMTileNeighbors::Left },
+        { DEMTileNeighbors::TopLeft, DEMTileNeighbors::BottomRight },
+        { DEMTileNeighbors::TopCenter, DEMTileNeighbors::BottomCenter },
+        { DEMTileNeighbors::TopRight, DEMTileNeighbors::BottomLeft },
+        { DEMTileNeighbors::BottomRight,  DEMTileNeighbors::TopLeft },
+        { DEMTileNeighbors::BottomCenter, DEMTileNeighbors:: TopCenter },
+        { DEMTileNeighbors::BottomLeft, DEMTileNeighbors::TopRight }
+    };
+
+    if (tile.isRenderable() && demtile.neighboringTiles != DEMTileNeighbors::Complete) {
+        const CanonicalTileID canonical = tile.id.canonical;
+        const uint32_t dim = std::pow(2, canonical.z);
+        const uint32_t px = (canonical.x - 1 + dim) % dim;
+        const int pxw = canonical.x == 0 ? tile.id.wrap - 1 : tile.id.wrap;
+        const uint32_t nx = (canonical.x + 1 + dim) % dim;
+        const int nxw = (canonical.x + 1 == dim) ? tile.id.wrap + 1 : tile.id.wrap;
+
+        auto getNeighbor = [&] (DEMTileNeighbors mask){
+            if (mask == DEMTileNeighbors::Left){
+                return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y);
+            } else if (mask == DEMTileNeighbors::Right){
+                return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y);
+            } else if (mask == DEMTileNeighbors::TopLeft){
+                return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y - 1);
+            } else if (mask == DEMTileNeighbors::TopCenter){
+                return OverscaledTileID(tile.id.overscaledZ, tile.id.wrap, canonical.z, canonical.x, canonical.y - 1);
+            } else if (mask == DEMTileNeighbors::TopRight){
+                return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y - 1);
+            } else if (mask == DEMTileNeighbors::BottomLeft){
+                return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y + 1);
+            } else if (mask == DEMTileNeighbors::BottomCenter){
+                return OverscaledTileID(tile.id.overscaledZ, tile.id.wrap, canonical.z, canonical.x, canonical.y + 1);
+            } else if (mask == DEMTileNeighbors::BottomRight){
+                return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y + 1);
+            } else{
+                throw std::runtime_error("mask is not a valid tile neighbor");
+            }
+        };
+
+        for (uint8_t i = 0; i < 8; i++) {
+            DEMTileNeighbors mask = DEMTileNeighbors(std::pow(2,i));
+            // only backfill if this neighbor has not been previously backfilled
+            if ((demtile.neighboringTiles & mask) != mask) {
+                OverscaledTileID neighborid = getNeighbor(mask);
+                Tile* renderableNeighbor = tilePyramid.getTile(neighborid);
+                if (renderableNeighbor != nullptr && renderableNeighbor->isRenderable()) {
+                    RasterDEMTile& borderTile = static_cast<RasterDEMTile&>(*renderableNeighbor);
+                    demtile.backfillBorder(borderTile, mask);
+
+                    // if the border tile has not been backfilled by a previous instance of the main
+                    // tile, backfill its corresponding neighbor as well.
+                    const DEMTileNeighbors& borderMask = opposites[mask];
+                    if ((borderTile.neighboringTiles & borderMask) != borderMask){
+                        borderTile.backfillBorder(demtile, borderMask);
+                     }
+                }
+            }
+        }
+    }
+    RenderSource::onTileChanged(tile);
+}
+
+void RenderRasterDEMSource::startRender(PaintParameters& parameters) {
+    algorithm::updateTileMasks(tilePyramid.getRenderTiles());
+    tilePyramid.startRender(parameters);
+}
+
+void RenderRasterDEMSource::finishRender(PaintParameters& parameters) {
+    tilePyramid.finishRender(parameters);
+}
+
+std::vector<std::reference_wrapper<RenderTile>> RenderRasterDEMSource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
+}
+
+std::unordered_map<std::string, std::vector<Feature>>
+RenderRasterDEMSource::queryRenderedFeatures(const ScreenLineString&,
+                                          const TransformState&,
+                                          const std::vector<const RenderLayer*>&,
+                                          const RenderedQueryOptions&,
+                                          const CollisionIndex& ) const {
+    return std::unordered_map<std::string, std::vector<Feature>> {};
+}
+
+std::vector<Feature> RenderRasterDEMSource::querySourceFeatures(const SourceQueryOptions&) const {
+    return {};
+}
+
+void RenderRasterDEMSource::reduceMemoryUse() {
+    tilePyramid.reduceMemoryUse();
+}
+
+void RenderRasterDEMSource::dumpDebugLogs() const {
+    tilePyramid.dumpDebugLogs();
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.hpp b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
new file mode 100644
index 0000000000..741214a14d
--- /dev/null
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/tile_pyramid.hpp>
+#include <mbgl/style/sources/raster_source_impl.hpp>
+
+namespace mbgl {
+
+class RenderRasterDEMSource : public RenderSource {
+public:
+    RenderRasterDEMSource(Immutable<style::RasterSource::Impl>);
+
+    bool isLoaded() const final;
+
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
+
+    void startRender(PaintParameters&) final;
+    void finishRender(PaintParameters&) final;
+
+    std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
+
+    std::unordered_map<std::string, std::vector<Feature>>
+    queryRenderedFeatures(const ScreenLineString& geometry,
+                          const TransformState& transformState,
+                          const std::vector<const RenderLayer*>& layers,
+                          const RenderedQueryOptions& options,
+                          const CollisionIndex& collisionIndex) const final;
+
+    std::vector<Feature>
+    querySourceFeatures(const SourceQueryOptions&) const final;
+
+    void reduceMemoryUse() final;
+    void dumpDebugLogs() const final;
+
+    uint8_t getMaxZoom() const {
+        return maxzoom;
+    };
+
+private:
+    const style::RasterSource::Impl& impl() const;
+
+    TilePyramid tilePyramid;
+    optional<Tileset> tileset;
+    uint8_t maxzoom = 15;
+
+protected:
+    void onTileChanged(Tile&) final;
+};
+
+template <>
+inline bool RenderSource::is<RenderRasterDEMSource>() const {
+    return baseImpl->type == style::SourceType::RasterDEM;
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index f11f9b7aed..60b3fa9a3b 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -29,14 +29,10 @@ void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_,
 
     enabled = needsRendering;
 
-    optional<Tileset> tileset = impl().getTileset();
+    optional<Tileset> _tileset = impl().getTileset();
 
-    if (!tileset) {
-        return;
-    }
-
-    if (tileURLTemplates != tileset->tiles) {
-        tileURLTemplates = tileset->tiles;
+    if (tileset != _tileset) {
+        tileset = _tileset;
 
         // TODO: this removes existing buckets, and will cause flickering.
         // Should instead refresh tile data in place.
@@ -44,6 +40,11 @@ void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_,
         tilePyramid.renderTiles.clear();
         tilePyramid.cache.clear();
     }
+    // Allow clearing the tile pyramid first, before the early return in case
+    //  the new tileset is not yet available or has an error in loading
+    if (!_tileset) {
+        return;
+    }
 
     tilePyramid.update(layers,
                        needsRendering,
@@ -52,6 +53,7 @@ void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_,
                        SourceType::Raster,
                        impl().getTileSize(),
                        tileset->zoomRange,
+                       tileset->bounds,
                        [&] (const OverscaledTileID& tileID) {
                            return std::make_unique<RasterTile>(tileID, parameters, *tileset);
                        });
@@ -83,8 +85,8 @@ std::vector<Feature> RenderRasterSource::querySourceFeatures(const SourceQueryOp
     return {};
 }
 
-void RenderRasterSource::onLowMemory() {
-    tilePyramid.onLowMemory();
+void RenderRasterSource::reduceMemoryUse() {
+    tilePyramid.reduceMemoryUse();
 }
 
 void RenderRasterSource::dumpDebugLogs() const {
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index 25041fde43..78eda199ac 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -33,14 +33,14 @@ public:
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void onLowMemory() final;
+    void reduceMemoryUse() final;
     void dumpDebugLogs() const final;
 
 private:
     const style::RasterSource::Impl& impl() const;
 
     TilePyramid tilePyramid;
-    optional<std::vector<std::string>> tileURLTemplates;
+    optional<Tileset> tileset;
 };
 
 template <>
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 49f8fdff2c..e87bea5dcd 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -32,14 +32,10 @@ void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_,
 
     enabled = needsRendering;
 
-    optional<Tileset> tileset = impl().getTileset();
+    optional<Tileset> _tileset = impl().getTileset();
 
-    if (!tileset) {
-        return;
-    }
-
-    if (tileURLTemplates != tileset->tiles) {
-        tileURLTemplates = tileset->tiles;
+    if (tileset != _tileset) {
+        tileset = _tileset;
 
         // TODO: this removes existing buckets, and will cause flickering.
         // Should instead refresh tile data in place.
@@ -47,6 +43,11 @@ void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_,
         tilePyramid.renderTiles.clear();
         tilePyramid.cache.clear();
     }
+    // Allow clearing the tile pyramid first, before the early return in case
+    //  the new tileset is not yet available or has an error in loading
+    if (!_tileset) {
+        return;
+    }
 
     tilePyramid.update(layers,
                        needsRendering,
@@ -55,6 +56,7 @@ void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_,
                        SourceType::Vector,
                        util::tileSize,
                        tileset->zoomRange,
+                       tileset->bounds,
                        [&] (const OverscaledTileID& tileID) {
                            return std::make_unique<VectorTile>(tileID, impl().id, parameters, *tileset);
                        });
@@ -86,8 +88,8 @@ std::vector<Feature> RenderVectorSource::querySourceFeatures(const SourceQueryOp
     return tilePyramid.querySourceFeatures(options);
 }
 
-void RenderVectorSource::onLowMemory() {
-    tilePyramid.onLowMemory();
+void RenderVectorSource::reduceMemoryUse() {
+    tilePyramid.reduceMemoryUse();
 }
 
 void RenderVectorSource::dumpDebugLogs() const {
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index 4a992e854f..592160dc16 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -33,14 +33,14 @@ public:
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void onLowMemory() final;
+    void reduceMemoryUse() final;
     void dumpDebugLogs() const final;
 
 private:
     const style::VectorSource::Impl& impl() const;
 
     TilePyramid tilePyramid;
-    optional<std::vector<std::string>> tileURLTemplates;
+    optional<Tileset> tileset;
 };
 
 template <>