Merge branch 'master' into Stephen-CJK

35 files changed, 172 insertions, 118 deletions

diff --git a/platform/android/CHANGELOG.md b/platform/android/CHANGELOG.md
index 9288256692..c699349bec 100644
--- a/platform/android/CHANGELOG.md
+++ b/platform/android/CHANGELOG.md
@@ -4,6 +4,8 @@ Mapbox welcomes participation and contributions from everyone.  If you'd like to
 
 ## master
 
+* Performance improvements for queryRenderedFeatures API and optimization that allocates containers based on a number of rendered layers. ([#14930](https://github.com/mapbox/mapbox-gl-native/pull/14930))
+
 ## 8.2.0-alpha.2 - July 3, 2019
 
 ### Bugs
diff --git a/platform/ios/CHANGELOG.md b/platform/ios/CHANGELOG.md
index 2162591846..00279ec242 100644
--- a/platform/ios/CHANGELOG.md
+++ b/platform/ios/CHANGELOG.md
@@ -5,6 +5,7 @@ Mapbox welcomes participation and contributions from everyone. Please read [CONT
 ## master
 
 * The `MGLIdeographicFontFamilyName` Info.plist key now also accepts an array of font family names, to customize font fallback behavior. It can also be set to a Boolean value of `NO` to force the SDK to typeset CJK characters in a remote font specified by `MGLSymbolStyleLayer.textFontNames`. ([#14862](https://github.com/mapbox/mapbox-gl-native/pull/14862))
+* Performance improvements for queryRenderedFeatures API and optimization that allocates containers based on a number of rendered layers. ([#14930](https://github.com/mapbox/mapbox-gl-native/pull/14930))
 
 ## 5.2.0
 
diff --git a/platform/macos/CHANGELOG.md b/platform/macos/CHANGELOG.md
index 40bb1905ad..8cbb3ee68d 100644
--- a/platform/macos/CHANGELOG.md
+++ b/platform/macos/CHANGELOG.md
@@ -5,6 +5,8 @@
 * Added an `MGLMapView.prefetchesTiles` property to configure lower-resolution tile prefetching behavior. ([#14816](https://github.com/mapbox/mapbox-gl-native/pull/14816))
 * Fixed queryRenderedFeatues bug caused by incorrect sort feature index calculation. ([#14884](https://github.com/mapbox/mapbox-gl-native/pull/14884))
 * The `MGLIdeographicFontFamilyName` Info.plist key now also accepts an array of font family names, to customize font fallback behavior. It can also be set to a Boolean value of `NO` to force the SDK to typeset CJK characters in a remote font specified by `MGLSymbolStyleLayer.textFontNames`. ([#14862](https://github.com/mapbox/mapbox-gl-native/pull/14862)) 
+* Performance improvements for queryRenderedFeatures API and optimization that allocates containers based on a number of rendered layers. ([#14930](https://github.com/mapbox/mapbox-gl-native/pull/14930))
+
 
 ### Styles and rendering
 
diff --git a/src/mbgl/annotation/render_annotation_source.cpp b/src/mbgl/annotation/render_annotation_source.cpp
index 123a776754..903825d5f5 100644
--- a/src/mbgl/annotation/render_annotation_source.cpp
+++ b/src/mbgl/annotation/render_annotation_source.cpp
@@ -46,7 +46,7 @@ void RenderAnnotationSource::update(Immutable<style::Source::Impl> baseImpl_,
 std::unordered_map<std::string, std::vector<Feature>>
 RenderAnnotationSource::queryRenderedFeatures(const ScreenLineString& geometry,
                                               const TransformState& transformState,
-                                              const std::vector<const RenderLayer*>& layers,
+                                              const std::unordered_map<std::string, const RenderLayer*>& layers,
                                               const RenderedQueryOptions& options,
                                               const mat4& projMatrix) const {
     return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix);
diff --git a/src/mbgl/annotation/render_annotation_source.hpp b/src/mbgl/annotation/render_annotation_source.hpp
index 948a0b0d8d..c920d760c2 100644
--- a/src/mbgl/annotation/render_annotation_source.hpp
+++ b/src/mbgl/annotation/render_annotation_source.hpp
@@ -18,7 +18,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const final;
 
diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp
index f61f89b8e7..3675e8bc6e 100644
--- a/src/mbgl/geometry/feature_index.cpp
+++ b/src/mbgl/geometry/feature_index.cpp
@@ -47,7 +47,7 @@ void FeatureIndex::query(
         const double scale,
         const RenderedQueryOptions& queryOptions,
         const UnwrappedTileID& tileID,
-        const std::vector<const RenderLayer*>& layers,
+        const std::unordered_map<std::string, const RenderLayer*>& layers,
         const float additionalQueryPadding) const {
     
     if (!tileData) {
@@ -81,7 +81,7 @@ void FeatureIndex::query(
 std::unordered_map<std::string, std::vector<Feature>>
 FeatureIndex::lookupSymbolFeatures(const std::vector<IndexedSubfeature>& symbolFeatures,
                                    const RenderedQueryOptions& queryOptions,
-                                   const std::vector<const RenderLayer*>& layers,
+                                   const std::unordered_map<std::string, const RenderLayer*>& layers,
                                    const OverscaledTileID& tileID,
                                    const std::shared_ptr<std::vector<size_t>>& featureSortOrder) const {
     std::unordered_map<std::string, std::vector<Feature>> result;
@@ -123,31 +123,24 @@ void FeatureIndex::addFeature(
     const IndexedSubfeature& indexedFeature,
     const RenderedQueryOptions& options,
     const CanonicalTileID& tileID,
-    const std::vector<const RenderLayer*>& layers,
+    const std::unordered_map<std::string, const RenderLayer*>& layers,
     const GeometryCoordinates& queryGeometry,
     const TransformState& transformState,
     const float pixelsToTileUnits,
     const mat4& posMatrix) const {
 
-    auto getRenderLayer = [&] (const std::string& layerID) -> const RenderLayer* {
-        for (const auto& layer : layers) {
-            if (layer->getID() == layerID) {
-                return layer;
-            }
-        }
-        return nullptr;
-    };
-
     // Lazily calculated.
     std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::unique_ptr<GeometryTileFeature> geometryTileFeature;
 
     for (const std::string& layerID : bucketLayerIDs.at(indexedFeature.bucketLeaderID)) {
-        const RenderLayer* renderLayer = getRenderLayer(layerID);
-        if (!renderLayer) {
+        const auto it = layers.find(layerID);
+        if (it == layers.end()) {
             continue;
         }
 
+        const RenderLayer* renderLayer = it->second;
+
         if (!geometryTileFeature) {
             sourceLayer = tileData->getLayer(indexedFeature.sourceLayerName);
             assert(sourceLayer);
diff --git a/src/mbgl/geometry/feature_index.hpp b/src/mbgl/geometry/feature_index.hpp
index cd041a7fdb..1a212761fa 100644
--- a/src/mbgl/geometry/feature_index.hpp
+++ b/src/mbgl/geometry/feature_index.hpp
@@ -67,7 +67,7 @@ public:
             const double scale,
             const RenderedQueryOptions& options,
             const UnwrappedTileID&,
-            const std::vector<const RenderLayer*>&,
+            const std::unordered_map<std::string, const RenderLayer*>&,
             const float additionalQueryPadding) const;
 
     static optional<GeometryCoordinates> translateQueryGeometry(
@@ -82,7 +82,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>> lookupSymbolFeatures(
            const std::vector<IndexedSubfeature>& symbolFeatures,
            const RenderedQueryOptions& options,
-           const std::vector<const RenderLayer*>& layers,
+           const std::unordered_map<std::string, const RenderLayer*>& layers,
            const OverscaledTileID& tileID,
            const std::shared_ptr<std::vector<size_t>>& featureSortOrder) const;
 
@@ -92,7 +92,7 @@ private:
             const IndexedSubfeature&,
             const RenderedQueryOptions& options,
             const CanonicalTileID&,
-            const std::vector<const RenderLayer*>&,
+            const std::unordered_map<std::string, const RenderLayer*>&,
             const GeometryCoordinates& queryGeometry,
             const TransformState& transformState,
             const float pixelsToTileUnits,
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index e7496df074..3888e9fec6 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -53,11 +53,12 @@ bool RenderCircleLayer::hasCrossfade() const {
 }
 
 void RenderCircleLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
 
-    for (const RenderTile& tile : renderTiles) {
+    for (const RenderTile& tile : *renderTiles) {
         const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 29002d8bdf..b8d195cfa1 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -56,6 +56,7 @@ bool RenderFillExtrusionLayer::hasCrossfade() const {
 }
 
 void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass != RenderPass::Translucent) {
         return;
     }
@@ -115,7 +116,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
     if (unevaluated.get<FillExtrusionPattern>().isUndefined()) {
         // Draw solid color extrusions
         auto drawTiles = [&](const gfx::StencilMode& stencilMode_, const gfx::ColorMode& colorMode_, const std::string& name) {
-            for (const RenderTile& tile : renderTiles) {
+            for (const RenderTile& tile : *renderTiles) {
                 const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
                 if (!renderData) {
                     continue;
@@ -162,7 +163,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
         // Draw textured extrusions
         const auto fillPatternValue = evaluated.get<FillExtrusionPattern>().constantOr(mbgl::Faded<std::basic_string<char> >{"", ""});
         auto drawTiles = [&](const gfx::StencilMode& stencilMode_, const gfx::ColorMode& colorMode_, const std::string& name) {
-            for (const RenderTile& tile : renderTiles) {
+            for (const RenderTile& tile : *renderTiles) {
                 const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
                 if (!renderData) {
                     continue;
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index c549b338df..6a3c247fbb 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -73,9 +73,10 @@ bool RenderFillLayer::hasCrossfade() const {
 }
 
 void RenderFillLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (unevaluated.get<FillPattern>().isUndefined()) {
         parameters.renderTileClippingMasks(renderTiles);
-        for (const RenderTile& tile : renderTiles) {
+        for (const RenderTile& tile : *renderTiles) {
             const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
@@ -162,7 +163,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
 
         parameters.renderTileClippingMasks(renderTiles);
 
-        for (const RenderTile& tile : renderTiles) {
+        for (const RenderTile& tile : *renderTiles) {
             const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 4b80dee5e7..e087d2ca69 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -63,6 +63,7 @@ void RenderHeatmapLayer::upload(gfx::UploadPass& uploadPass) {
 }
 
 void RenderHeatmapLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
@@ -93,7 +94,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
         auto renderPass = parameters.encoder->createRenderPass(
             "heatmap texture", { *renderTexture, Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {} });
 
-        for (const RenderTile& tile : renderTiles) {
+        for (const RenderTile& tile : *renderTiles) {
             const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 2cbb77f24b..9d1b5293c1 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -71,6 +71,7 @@ void RenderHillshadeLayer::prepare(const LayerPrepareParameters& params) {
 }
 
 void RenderHillshadeLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
         return;
     const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;  
@@ -126,7 +127,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
     matrix::ortho(mat, 0, util::EXTENT, -util::EXTENT, 0, 0, 1);
     matrix::translate(mat, mat, 0, -util::EXTENT, 0);
 
-    for (const RenderTile& tile : renderTiles) {
+    for (const RenderTile& tile : *renderTiles) {
         auto* bucket_ = tile.getBucket(*baseImpl);
         if (!bucket_) {
             continue;
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 595140634d..061be0aba1 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -61,7 +61,7 @@ bool RenderLineLayer::hasCrossfade() const {
 
 void RenderLineLayer::prepare(const LayerPrepareParameters& params) {
     RenderLayer::prepare(params);
-    for (const RenderTile& tile : renderTiles) {
+    for (const RenderTile& tile : *renderTiles) {
         const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) continue;
 
@@ -84,13 +84,14 @@ void RenderLineLayer::upload(gfx::UploadPass& uploadPass) {
 }
 
 void RenderLineLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
 
     parameters.renderTileClippingMasks(renderTiles);
 
-    for (const RenderTile& tile : renderTiles) {
+    for (const RenderTile& tile : *renderTiles) {
         const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index e22e14275c..ce1fa52f5e 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -74,8 +74,9 @@ static std::array<float, 3> spinWeights(float spin) {
 }
 
 void RenderRasterLayer::prepare(const LayerPrepareParameters& params) {
-    RenderLayer::prepare(params);
+    renderTiles = params.source->getRenderTiles();
     imageData = params.source->getImageRenderData();
+    assert(renderTiles || imageData);
 }
 
 void RenderRasterLayer::render(PaintParameters& parameters) {
@@ -153,8 +154,8 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
                 },
                 bucket.drawScopeID + std::to_string(i++));
         }
-    } else {
-        for (const RenderTile& tile : renderTiles) {
+    } else if (renderTiles) {
+        for (const RenderTile& tile : *renderTiles) {
             auto* bucket_ = tile.getBucket(*baseImpl);
             if (!bucket_) {
                 continue;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 60b0c8e2d8..b24e088ac4 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -276,6 +276,7 @@ bool RenderSymbolLayer::hasCrossfade() const {
 }
 
 void RenderSymbolLayer::render(PaintParameters& parameters) {
+    assert(renderTiles);
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
@@ -348,7 +349,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
         );
     };
 
-    for (const RenderTile& tile : renderTiles) {
+    for (const RenderTile& tile : *renderTiles) {
         const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
@@ -493,22 +494,11 @@ style::TextPaintProperties::PossiblyEvaluated RenderSymbolLayer::textPaintProper
 }
 
 void RenderSymbolLayer::prepare(const LayerPrepareParameters& params) {
-    renderTiles = params.source->getRenderTiles();
-    const auto comp = [bearing = params.state.getBearing()](const RenderTile& a, const RenderTile& b) {
-        Point<float> pa(a.id.canonical.x, a.id.canonical.y);
-        Point<float> pb(b.id.canonical.x, b.id.canonical.y);
-
-        auto par = util::rotate(pa, bearing);
-        auto pbr = util::rotate(pb, bearing);
-
-        return std::tie(b.id.canonical.z, par.y, par.x) < std::tie(a.id.canonical.z, pbr.y, pbr.x);
-    };
-    // Sort symbol tiles in opposite y position, so tiles with overlapping symbols are drawn
-    // on top of each other, with lower symbols being drawn on top of higher symbols.
-    std::sort(renderTiles.begin(), renderTiles.end(), comp);
+    renderTiles = params.source->getRenderTilesSortedByYPosition();
+    assert(renderTiles);
 
     placementData.clear();
-    for (const RenderTile& renderTile : renderTiles) {
+    for (const RenderTile& renderTile : *renderTiles) {
         auto* bucket = static_cast<SymbolBucket*>(renderTile.getBucket(*baseImpl));
         if (bucket && bucket->bucketLeaderID == getID()) {
             // Only place this layer if it's the "group leader" for the bucket
diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp
index 0bb66972a8..1539c0fbcb 100644
--- a/src/mbgl/renderer/paint_parameters.cpp
+++ b/src/mbgl/renderer/paint_parameters.cpp
@@ -92,24 +92,25 @@ namespace {
 // Detects a difference in keys of renderTiles and tileClippingMaskIDs
 bool tileIDsIdentical(const RenderTiles& renderTiles,
                       const std::map<UnwrappedTileID, int32_t>& tileClippingMaskIDs) {
-    assert(std::is_sorted(renderTiles.begin(), renderTiles.end(),
+    assert(renderTiles);
+    assert(std::is_sorted(renderTiles->begin(), renderTiles->end(),
                           [](const RenderTile& a, const RenderTile& b) { return a.id < b.id; }));
-    if (renderTiles.size() != tileClippingMaskIDs.size()) {
+    if (renderTiles->size() != tileClippingMaskIDs.size()) {
         return false;
     }
-    return std::equal(renderTiles.begin(), renderTiles.end(), tileClippingMaskIDs.begin(),
+    return std::equal(renderTiles->begin(), renderTiles->end(), tileClippingMaskIDs.begin(),
                       [](const RenderTile& a, const auto& b) { return a.id == b.first; });
 }
 
 } // namespace
 
 void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) {
-    if (renderTiles.empty() || tileIDsIdentical(renderTiles, tileClippingMaskIDs)) {
+    if (!renderTiles || renderTiles->empty() || tileIDsIdentical(renderTiles, tileClippingMaskIDs)) {
         // The current stencil mask is for this source already; no need to draw another one.
         return;
     }
 
-    if (nextStencilID + renderTiles.size() > 256) {
+    if (nextStencilID + renderTiles->size() > 256) {
         // we'll run out of fresh IDs so we need to clear and start from scratch
         clearStencil();
     }
@@ -120,7 +121,7 @@ void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) {
     const style::Properties<>::PossiblyEvaluated properties {};
     const ClippingMaskProgram::Binders paintAttributeData(properties, 0);
 
-    for (const RenderTile& renderTile : renderTiles) {
+    for (const RenderTile& renderTile : *renderTiles) {
         const int32_t stencilID = nextStencilID++;
         tileClippingMaskIDs.emplace(renderTile.id, stencilID);
 
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index 9e79d7338c..b92b28998c 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -47,25 +47,14 @@ bool RenderLayer::supportsZoom(float zoom) const {
 
 void RenderLayer::prepare(const LayerPrepareParameters& params) {
     assert(params.source);
-    renderTiles = filterRenderTiles(params.source->getRenderTiles());
+    renderTiles = params.source->getRenderTiles();
+    assert(renderTiles);
 }
 
 optional<Color> RenderLayer::getSolidBackground() const {
     return nullopt;
 }
 
-RenderTiles RenderLayer::filterRenderTiles(RenderTiles tiles) const {
-    RenderTiles filtered;
-
-    for (const RenderTile& tile : tiles) {
-        if (tile.holdForFade()) {
-            continue;
-        }
-        filtered.emplace_back(tile);
-    }
-    return filtered;
-}
-
 void RenderLayer::markContextDestroyed() {
     // no-op
 }
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 11c7587893..c7efdceab4 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <mbgl/layout/layout.hpp>
 #include <mbgl/renderer/render_pass.hpp>
+#include <mbgl/renderer/render_source.hpp>
 #include <mbgl/style/layer_properties.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/util/mat4.hpp>
@@ -15,7 +16,6 @@ class TransitionParameters;
 class PropertyEvaluationParameters;
 class UploadParameters;
 class PaintParameters;
-class RenderSource;
 class RenderTile;
 class TransformState;
 class PatternAtlas;
@@ -43,8 +43,6 @@ public:
     const TransformState& state;
 };
 
-using RenderTiles = std::vector<std::reference_wrapper<const RenderTile>>;
-
 class RenderLayer {
 protected:
     RenderLayer(Immutable<style::LayerProperties>);
@@ -127,7 +125,6 @@ protected:
     std::vector<LayerPlacementData> placementData;
 
 private:
-    RenderTiles filterRenderTiles(RenderTiles) const;
     // Some layers may not render correctly on some hardware when the vertex attribute limit of
     // that GPU is exceeded. More attributes are used when adding many data driven paint properties
     // to a layer.
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index fafbc8b635..7df74cda71 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -271,11 +271,17 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
     std::vector<std::reference_wrapper<RenderLayer>> layersNeedPlacement;
     auto renderItemsEmplaceHint = layerRenderItems.begin();
 
+    // Reserve size for filteredLayersForSource if there are sources.
+    if (!sourceImpls->empty()) {
+        filteredLayersForSource.reserve(layerImpls->size());
+        if (filteredLayersForSource.capacity() > layerImpls->size()) {
+            filteredLayersForSource.shrink_to_fit();
+        }
+    }
+
     // Update all sources and initialize renderItems.
     for (const auto& sourceImpl : *sourceImpls) {
         RenderSource* source = renderSources.at(sourceImpl->id).get();
-        std::vector<Immutable<LayerProperties>> filteredLayersForSource;
-        filteredLayersForSource.reserve(layerImpls->size());
         bool sourceNeedsRendering = false;
         bool sourceNeedsRelayout = false;       
         
@@ -321,6 +327,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
                        sourceNeedsRendering,
                        sourceNeedsRelayout,
                        tileParameters);
+        filteredLayersForSource.clear();
     }
 
     renderTreeParameters->loaded = updateParameters.styleLoaded && isLoaded();
@@ -409,16 +416,16 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
 }
 
 std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options) const {
-    std::vector<const RenderLayer*> layers;
+    std::unordered_map<std::string, const RenderLayer*> layers;
     if (options.layerIDs) {
         for (const auto& layerID : *options.layerIDs) {
             if (const RenderLayer* layer = getRenderLayer(layerID)) {
-                layers.emplace_back(layer);
+                layers.emplace(layer->getID(), layer);
             }
         }
     } else {
         for (const auto& entry : renderLayers) {
-            layers.emplace_back(entry.second.get());
+            layers.emplace(entry.second->getID(), entry.second.get());
         }
     }
 
@@ -427,9 +434,22 @@ std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineS
     
 void RenderOrchestrator::queryRenderedSymbols(std::unordered_map<std::string, std::vector<Feature>>& resultsByLayer,
                                           const ScreenLineString& geometry,
-                                          const std::vector<const RenderLayer*>& layers,
+                                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                                           const RenderedQueryOptions& options) const {
-    
+    const auto hasCrossTileIndex = [] (const auto& pair) {
+        return pair.second->baseImpl->getTypeInfo()->crossTileIndex == style::LayerTypeInfo::CrossTileIndex::Required;
+    };
+
+    std::unordered_map<std::string, const RenderLayer*> crossTileSymbolIndexLayers;
+    std::copy_if(layers.begin(),
+                 layers.end(),
+                 std::inserter(crossTileSymbolIndexLayers, crossTileSymbolIndexLayers.begin()),
+                 hasCrossTileIndex);
+
+    if (crossTileSymbolIndexLayers.empty()) {
+        return;
+    }
+
     auto renderedSymbols = placement->getCollisionIndex().queryRenderedSymbols(geometry);
     std::vector<std::reference_wrapper<const RetainedQueryData>> bucketQueryData;
     for (auto entry : renderedSymbols) {
@@ -447,7 +467,7 @@ void RenderOrchestrator::queryRenderedSymbols(std::unordered_map<std::string, st
         auto& queryData = wrappedQueryData.get();
         auto bucketSymbols = queryData.featureIndex->lookupSymbolFeatures(renderedSymbols[queryData.bucketInstanceId],
                                                                           options,
-                                                                          layers,
+                                                                          crossTileSymbolIndexLayers,
                                                                           queryData.tileID,
                                                                           queryData.featureSortOrder);
         
@@ -458,10 +478,10 @@ void RenderOrchestrator::queryRenderedSymbols(std::unordered_map<std::string, st
     }
 }
 
-std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options, const std::vector<const RenderLayer*>& layers) const {
+std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options, const std::unordered_map<std::string, const RenderLayer*>& layers) const {
     std::unordered_set<std::string> sourceIDs;
-    for (const RenderLayer* layer : layers) {
-        sourceIDs.emplace(layer->baseImpl->source);
+    for (const auto& pair : layers) {
+        sourceIDs.emplace(pair.second->baseImpl->source);
     }
 
     mat4 projMatrix;
@@ -484,13 +504,12 @@ std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineS
     }
 
     // Combine all results based on the style layer renderItems.
-    for (const auto& layerImpl : *layerImpls) {
-        const RenderLayer* layer = getRenderLayer(layerImpl->id);
-        if (!layer->needsRendering() || !layer->supportsZoom(zoomHistory.lastZoom)) {
+    for (const auto& pair : layers) {
+        if (!pair.second->needsRendering() || !pair.second->supportsZoom(zoomHistory.lastZoom)) {
             continue;
         }
 
-        auto it = resultsByLayer.find(layer->baseImpl->id);
+        auto it = resultsByLayer.find(pair.second->baseImpl->id);
         if (it != resultsByLayer.end()) {
             std::move(it->second.begin(), it->second.end(), std::back_inserter(result));
         }
@@ -501,13 +520,13 @@ std::vector<Feature> RenderOrchestrator::queryRenderedFeatures(const ScreenLineS
 
 std::vector<Feature> RenderOrchestrator::queryShapeAnnotations(const ScreenLineString& geometry) const {
     assert(LayerManager::annotationsEnabled);
-    std::vector<const RenderLayer*> shapeAnnotationLayers;
+    std::unordered_map<std::string, const RenderLayer*> shapeAnnotationLayers;
     RenderedQueryOptions options;
     for (const auto& layerImpl : *layerImpls) {
         if (std::mismatch(layerImpl->id.begin(), layerImpl->id.end(),
                           AnnotationManager::ShapeLayerID.begin(), AnnotationManager::ShapeLayerID.end()).second == AnnotationManager::ShapeLayerID.end()) {
             if (const RenderLayer* layer = getRenderLayer(layerImpl->id)) {
-                shapeAnnotationLayers.emplace_back(layer);
+                shapeAnnotationLayers.emplace(layer->getID(), layer);
             }
         }
     }
diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp
index a60bac2e16..884bd21b7b 100644
--- a/src/mbgl/renderer/render_orchestrator.hpp
+++ b/src/mbgl/renderer/render_orchestrator.hpp
@@ -33,6 +33,10 @@ class PatternAtlas;
 class CrossTileSymbolIndex;
 class RenderTree;
 
+namespace style {
+    class LayerProperties;
+} // namespace style
+
 class RenderOrchestrator final : public GlyphManagerObserver,
                                  public ImageManagerObserver,
                                  public RenderSourceObserver {
@@ -74,10 +78,10 @@ private:
               
     void queryRenderedSymbols(std::unordered_map<std::string, std::vector<Feature>>& resultsByLayer,
                               const ScreenLineString& geometry,
-                              const std::vector<const RenderLayer*>& layers,
+                              const std::unordered_map<std::string, const RenderLayer*>& layers,
                               const RenderedQueryOptions& options) const;
     
-    std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions&, const std::vector<const RenderLayer*>&) const;
+    std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions&, const std::unordered_map<std::string, const RenderLayer*>&) const;
 
     // GlyphManagerObserver implementation.
     void onGlyphsError(const FontStack&, const GlyphRange&, std::exception_ptr) override;
@@ -113,6 +117,10 @@ private:
 
     const bool backgroundLayerAsColor;
     bool contextLost = false;
+
+    // Vector with reserved capacity of layerImpls->size() to avoid reallocation
+    // on each frame.
+    std::vector<Immutable<style::LayerProperties>> filteredLayersForSource;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index fc770f83cf..cd471223a8 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -43,7 +43,7 @@ public:
     const ImageManager& imageManager;
 };
 
-using RenderTiles = std::vector<std::reference_wrapper<const RenderTile>>;
+using RenderTiles = std::shared_ptr<const std::vector<std::reference_wrapper<const RenderTile>>>;
 
 class RenderSource : protected TileObserver {
 public:
@@ -64,15 +64,21 @@ public:
     virtual void prepare(const SourcePrepareParameters&) = 0;
     virtual void updateFadingTiles() = 0;
     virtual bool hasFadingTiles() const = 0;
-    // Returns a list of RenderTiles, sorted by tile id.
-    virtual RenderTiles getRenderTiles() = 0;
+    // If supported, returns a shared list of RenderTiles, sorted by tile id and excluding tiles hold for fade;
+    // returns nullptr otherwise.
+    virtual RenderTiles getRenderTiles() const { return nullptr; }
+    // If supported, returns a shared list of RenderTiles, sorted in opposite y position, so tiles with overlapping
+    // symbols are drawn on top of each other, with lower symbols being drawn on top of higher symbols;
+    // returns nullptr otherwise.
+    virtual RenderTiles getRenderTilesSortedByYPosition() const { return nullptr; }
+    // If supported, returns pointer to image data; returns nullptr otherwise.
     virtual const ImageSourceRenderData* getImageRenderData() const { return nullptr; }
     virtual const Tile* getRenderedTile(const UnwrappedTileID&) const { return nullptr; }
 
     virtual std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const = 0;
 
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 7e793c6a4a..6d197df9db 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -106,7 +106,7 @@ void RenderImageSource::prepare(const SourcePrepareParameters& parameters) {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderImageSource::queryRenderedFeatures(const ScreenLineString&,
                                          const TransformState&,
-                                         const std::vector<const RenderLayer*>&,
+                                         const std::unordered_map<std::string, const RenderLayer*>&,
                                          const RenderedQueryOptions&,
                                          const mat4&) const {
     return std::unordered_map<std::string, std::vector<Feature>> {};
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index d21f4fae10..da0d899624 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -48,8 +48,6 @@ public:
                 bool needsRelayout,
                 const TileParameters&) final;
 
-    RenderTiles getRenderTiles() override { return {}; }
-
     const ImageSourceRenderData* getImageRenderData() const override { 
         return renderData.get();
     }
@@ -57,7 +55,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const final;
 
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.cpp b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
index 9854b4fdc3..841124fa4a 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
@@ -125,7 +125,7 @@ void RenderRasterDEMSource::onTileChanged(Tile& tile){
 std::unordered_map<std::string, std::vector<Feature>>
 RenderRasterDEMSource::queryRenderedFeatures(const ScreenLineString&,
                                           const TransformState&,
-                                          const std::vector<const RenderLayer*>&,
+                                          const std::unordered_map<std::string, const RenderLayer*>&,
                                           const RenderedQueryOptions&,
                                           const mat4&) const {
     return std::unordered_map<std::string, std::vector<Feature>>{};
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.hpp b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
index e49ad1d1d4..dd74f4d7e7 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
@@ -19,7 +19,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const override;
 
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index 827ffb9759..06eb36795b 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -60,7 +60,7 @@ void RenderRasterSource::prepare(const SourcePrepareParameters& parameters) {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderRasterSource::queryRenderedFeatures(const ScreenLineString&,
                                           const TransformState&,
-                                          const std::vector<const RenderLayer*>&,
+                                          const std::unordered_map<std::string, const RenderLayer*>&,
                                           const RenderedQueryOptions&,
                                           const mat4&) const {
     return std::unordered_map<std::string, std::vector<Feature>>{};
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index dc80630add..0071dddec9 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -19,7 +19,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const override;
 
diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp
index 99bdfde485..6ee2eca1b1 100644
--- a/src/mbgl/renderer/sources/render_tile_source.cpp
+++ b/src/mbgl/renderer/sources/render_tile_source.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/tile_render_data.hpp>
 #include <mbgl/tile/vector_tile.hpp>
+#include <mbgl/util/math.hpp>
 
 namespace mbgl {
 
@@ -56,6 +57,9 @@ std::unique_ptr<RenderItem> RenderTileSource::createRenderItem() {
 }
 
 void RenderTileSource::prepare(const SourcePrepareParameters& parameters) {
+    bearing = parameters.transform.state.getBearing();
+    filteredRenderTiles = nullptr;
+    renderTilesSortedByY = nullptr;
     auto tiles = makeMutable<std::vector<RenderTile>>();
     tiles->reserve(tilePyramid.getRenderedTiles().size());
     for (auto& entry : tilePyramid.getRenderedTiles()) {
@@ -73,8 +77,41 @@ bool RenderTileSource::hasFadingTiles() const {
     return tilePyramid.hasFadingTiles();
 }
 
-RenderTiles RenderTileSource::getRenderTiles() {
-    return { renderTiles->begin(), renderTiles->end() };
+RenderTiles RenderTileSource::getRenderTiles() const {
+    if (!filteredRenderTiles) {
+        auto result = std::make_shared<std::vector<std::reference_wrapper<const RenderTile>>>();
+        for (const auto& renderTile : *renderTiles) {
+            if (renderTile.holdForFade()) {
+                continue;
+            }
+            result->emplace_back(renderTile);
+        }
+        filteredRenderTiles = std::move(result);
+    }
+    return filteredRenderTiles;
+}
+
+RenderTiles RenderTileSource::getRenderTilesSortedByYPosition() const {
+    if (!renderTilesSortedByY) {
+        const auto comp = [bearing = this->bearing](const RenderTile& a, const RenderTile& b) {
+            Point<float> pa(a.id.canonical.x, a.id.canonical.y);
+            Point<float> pb(b.id.canonical.x, b.id.canonical.y);
+
+            auto par = util::rotate(pa, bearing);
+            auto pbr = util::rotate(pb, bearing);
+
+            return std::tie(b.id.canonical.z, par.y, par.x) < std::tie(a.id.canonical.z, pbr.y, pbr.x);
+        };
+
+        auto result = std::make_shared<std::vector<std::reference_wrapper<const RenderTile>>>();
+        result->reserve(renderTiles->size());
+        for (const auto& renderTile : *renderTiles) {
+            result->emplace_back(renderTile);
+        }
+        std::sort(result->begin(), result->end(), comp);
+        renderTilesSortedByY = std::move(result);
+    }
+    return renderTilesSortedByY;
 }
 
 const Tile* RenderTileSource::getRenderedTile(const UnwrappedTileID& tileID) const {
@@ -84,7 +121,7 @@ const Tile* RenderTileSource::getRenderedTile(const UnwrappedTileID& tileID) con
 std::unordered_map<std::string, std::vector<Feature>>
 RenderTileSource::queryRenderedFeatures(const ScreenLineString& geometry,
                                           const TransformState& transformState,
-                                          const std::vector<const RenderLayer*>& layers,
+                                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                                           const RenderedQueryOptions& options,
                                           const mat4& projMatrix) const {
     return tilePyramid.queryRenderedFeatures(geometry, transformState, layers, options, projMatrix);
diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp
index e3148b45b9..f961c20561 100644
--- a/src/mbgl/renderer/sources/render_tile_source.hpp
+++ b/src/mbgl/renderer/sources/render_tile_source.hpp
@@ -21,13 +21,14 @@ public:
     void updateFadingTiles() override;
     bool hasFadingTiles() const override;
 
-    RenderTiles getRenderTiles() override;
+    RenderTiles getRenderTiles() const override;
+    RenderTiles getRenderTilesSortedByYPosition() const override;
     const Tile* getRenderedTile(const UnwrappedTileID&) const override;
 
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>& layers,
+                          const std::unordered_map<std::string, const RenderLayer*>& layers,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const override;
 
@@ -40,6 +41,9 @@ public:
 protected:
     TilePyramid tilePyramid;
     Immutable<std::vector<RenderTile>> renderTiles;
+    mutable RenderTiles filteredRenderTiles;
+    mutable RenderTiles renderTilesSortedByY;
+    float bearing = 0.0f;      
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index e08803134d..f47198e275 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -284,7 +284,7 @@ void TilePyramid::handleWrapJump(float lng) {
 
 std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRenderedFeatures(const ScreenLineString& geometry,
                                            const TransformState& transformState,
-                                           const std::vector<const RenderLayer*>& layers,
+                                           const std::unordered_map<std::string, const RenderLayer*>& layers,
                                            const RenderedQueryOptions& options,
                                            const mat4& projMatrix) const {
     std::unordered_map<std::string, std::vector<Feature>> result;
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index 675831fbc9..f80eb0db78 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -52,7 +52,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const std::vector<const RenderLayer*>&,
+                          const std::unordered_map<std::string, const RenderLayer*>&,
                           const RenderedQueryOptions& options,
                           const mat4& projMatrix) const;
 
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index e87d21503a..7f1bed49f4 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -291,12 +291,12 @@ LayerRenderData* GeometryTile::getLayerRenderData(const style::Layer::Impl& laye
     return layoutResult ? layoutResult->getLayerRenderData(layerImpl) : nullptr;
 }
 
-float GeometryTile::getQueryPadding(const std::vector<const RenderLayer*>& layers) {
+float GeometryTile::getQueryPadding(const std::unordered_map<std::string, const RenderLayer*>& layers) {
     float queryPadding = 0;
-    for (const RenderLayer* layer : layers) {
-        const LayerRenderData* data = getLayerRenderData(*layer->baseImpl);
+    for (const auto& pair : layers) {
+        const LayerRenderData* data = getLayerRenderData(*pair.second->baseImpl);
         if (data && data->bucket && data->bucket->hasData()) {
-            queryPadding = std::max(queryPadding, data->bucket->getQueryRadius(*layer));
+            queryPadding = std::max(queryPadding, data->bucket->getQueryRadius(*pair.second));
         }
     }
     return queryPadding;
@@ -306,7 +306,7 @@ void GeometryTile::queryRenderedFeatures(
     std::unordered_map<std::string, std::vector<Feature>>& result,
     const GeometryCoordinates& queryGeometry,
     const TransformState& transformState,
-    const std::vector<const RenderLayer*>& layers,
+    const std::unordered_map<std::string, const RenderLayer*>& layers,
     const RenderedQueryOptions& options,
     const mat4& projMatrix) {
 
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 3d75dfc456..7c46edfc1d 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -52,7 +52,7 @@ public:
             std::unordered_map<std::string, std::vector<Feature>>& result,
             const GeometryCoordinates& queryGeometry,
             const TransformState&,
-            const std::vector<const RenderLayer*>& layers,
+            const std::unordered_map<std::string, const RenderLayer*>& layers,
             const RenderedQueryOptions& options,
             const mat4& projMatrix) override;
 
@@ -60,7 +60,7 @@ public:
         std::vector<Feature>& result,
         const SourceQueryOptions&) override;
 
-    float getQueryPadding(const std::vector<const RenderLayer*>&) override;
+    float getQueryPadding(const std::unordered_map<std::string, const RenderLayer*>&) override;
 
     void cancel() override;
 
diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp
index 5e31898caf..2f342c092d 100644
--- a/src/mbgl/tile/tile.cpp
+++ b/src/mbgl/tile/tile.cpp
@@ -43,11 +43,11 @@ void Tile::queryRenderedFeatures(
         std::unordered_map<std::string, std::vector<Feature>>&,
         const GeometryCoordinates&,
         const TransformState&,
-        const std::vector<const RenderLayer*>&,
+        const std::unordered_map<std::string, const RenderLayer*>&,
         const RenderedQueryOptions&,
         const mat4&) {}
 
-float Tile::getQueryPadding(const std::vector<const RenderLayer*>&) {
+float Tile::getQueryPadding(const std::unordered_map<std::string, const RenderLayer*>&) {
     return 0;
 }
 
diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp
index 4ba8bc1160..7a7d246aa6 100644
--- a/src/mbgl/tile/tile.hpp
+++ b/src/mbgl/tile/tile.hpp
@@ -71,7 +71,7 @@ public:
             std::unordered_map<std::string, std::vector<Feature>>& result,
             const GeometryCoordinates& queryGeometry,
             const TransformState&,
-            const std::vector<const RenderLayer*>&,
+            const std::unordered_map<std::string, const RenderLayer*>&,
             const RenderedQueryOptions& options,
             const mat4& projMatrix);
 
@@ -79,7 +79,7 @@ public:
             std::vector<Feature>& result,
             const SourceQueryOptions&);
 
-    virtual float getQueryPadding(const std::vector<const RenderLayer*>&);
+    virtual float getQueryPadding(const std::unordered_map<std::string, const RenderLayer*>&);
 
     void setTriedCache();