1 files changed, 487 insertions, 99 deletions

diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index dd3c0d41a1..6a8c18792e 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -1,13 +1,32 @@
+#include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/renderer/renderer_impl.hpp>
-#include <mbgl/renderer/render_style.hpp>
+#include <mbgl/renderer/renderer_backend.hpp>
+#include <mbgl/renderer/renderer_observer.hpp>
+#include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
-#include <mbgl/renderer/render_item.hpp>
 #include <mbgl/renderer/update_parameters.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
+#include <mbgl/renderer/transition_parameters.hpp>
+#include <mbgl/renderer/property_evaluation_parameters.hpp>
+#include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/layers/render_background_layer.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
+#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
+#include <mbgl/renderer/style_diff.hpp>
+#include <mbgl/renderer/query.hpp>
 #include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/gl/debugging.hpp>
 #include <mbgl/geometry/line_atlas.hpp>
+#include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/transition_options.hpp>
+#include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/tile/tile.hpp>
+#include <mbgl/util/math.hpp>
+#include <mbgl/util/string.hpp>
+#include <mbgl/util/logging.hpp>
 
 namespace mbgl {
 
@@ -24,20 +43,36 @@ Renderer::Impl::Impl(RendererBackend& backend_,
                      Scheduler& scheduler_,
                      GLContextMode contextMode_,
                      const optional<std::string> programCacheDir_)
-        : backend(backend_)
-        , observer(&nullObserver())
-        , contextMode(contextMode_)
-        , pixelRatio(pixelRatio_)
-        , programCacheDir(programCacheDir_)
-        , renderStyle(std::make_unique<RenderStyle>(scheduler_, fileSource_)) {
-
-    renderStyle->setObserver(this);
+    : backend(backend_)
+    , scheduler(scheduler_)
+    , fileSource(fileSource_)
+    , observer(&nullObserver())
+    , contextMode(contextMode_)
+    , pixelRatio(pixelRatio_)
+    , programCacheDir(programCacheDir_)
+    , glyphManager(std::make_unique<GlyphManager>(fileSource))
+    , imageManager(std::make_unique<ImageManager>())
+    , lineAtlas(std::make_unique<LineAtlas>(Size{ 256, 512 }))
+    , imageImpls(makeMutable<std::vector<Immutable<style::Image::Impl>>>())
+    , sourceImpls(makeMutable<std::vector<Immutable<style::Source::Impl>>>())
+    , layerImpls(makeMutable<std::vector<Immutable<style::Layer::Impl>>>())
+    , renderLight(makeMutable<Light::Impl>()) {
+    glyphManager->setObserver(this);
 }
 
 Renderer::Impl::~Impl() {
-    BackendScope guard { backend };
-    renderStyle.reset();
-    staticData.reset();
+    assert(BackendScope::exists());
+
+    if (contextLost) {
+        // Signal all RenderCustomLayers that the context was lost
+        // before cleaning up
+        for (const auto& entry : renderLayers) {
+            RenderLayer& layer = *entry.second;
+            if (layer.is<RenderCustomLayer>()) {
+                layer.as<RenderCustomLayer>()->markContextDestroyed();
+            }
+        }
+    }
 };
 
 void Renderer::Impl::setObserver(RendererObserver* observer_) {
@@ -45,12 +80,164 @@ void Renderer::Impl::setObserver(RendererObserver* observer_) {
 }
 
 void Renderer::Impl::render(const UpdateParameters& updateParameters) {
-    // Don't load/render anyting in still mode until explicitly requested.
-    if (updateParameters.mode == MapMode::Still && !updateParameters.stillImageRequest) return;
+    if (updateParameters.mode == MapMode::Still) {
+        // Don't load/render anyting in still mode until explicitly requested.
+        if (!updateParameters.stillImageRequest) {
+            return;
+        }
+
+        // Reset zoom history state.
+        zoomHistory.first = true;
+    }
     
     assert(BackendScope::exists());
+    
+    updateParameters.annotationManager.updateData();
+
+    const bool zoomChanged = zoomHistory.update(updateParameters.transformState.getZoom(), updateParameters.timePoint);
+
+    const TransitionParameters transitionParameters {
+        updateParameters.timePoint,
+        updateParameters.mode == MapMode::Continuous ? updateParameters.transitionOptions : TransitionOptions()
+    };
+
+    const PropertyEvaluationParameters evaluationParameters {
+        zoomHistory,
+        updateParameters.timePoint,
+        updateParameters.mode == MapMode::Continuous ? util::DEFAULT_TRANSITION_DURATION : Duration::zero()
+    };
+
+    const TileParameters tileParameters {
+        updateParameters.pixelRatio,
+        updateParameters.debugOptions,
+        updateParameters.transformState,
+        scheduler,
+        fileSource,
+        updateParameters.mode,
+        updateParameters.annotationManager,
+        *imageManager,
+        *glyphManager,
+        updateParameters.prefetchZoomDelta
+    };
+
+    glyphManager->setURL(updateParameters.glyphURL);
+
+    // Update light.
+    const bool lightChanged = renderLight.impl != updateParameters.light;
+
+    if (lightChanged) {
+        renderLight.impl = updateParameters.light;
+        renderLight.transition(transitionParameters);
+    }
+
+    if (lightChanged || zoomChanged || renderLight.hasTransition()) {
+        renderLight.evaluate(evaluationParameters);
+    }
+
+
+    const ImageDifference imageDiff = diffImages(imageImpls, updateParameters.images);
+    imageImpls = updateParameters.images;
+
+    // Remove removed images from sprite atlas.
+    for (const auto& entry : imageDiff.removed) {
+        imageManager->removeImage(entry.first);
+    }
+
+    // Add added images to sprite atlas.
+    for (const auto& entry : imageDiff.added) {
+        imageManager->addImage(entry.second);
+    }
+
+    // Update changed images.
+    for (const auto& entry : imageDiff.changed) {
+        imageManager->updateImage(entry.second.after);
+    }
+
+    imageManager->setLoaded(updateParameters.spriteLoaded);
+
+
+    const LayerDifference layerDiff = diffLayers(layerImpls, updateParameters.layers);
+    layerImpls = updateParameters.layers;
+
+    // Remove render layers for removed layers.
+    for (const auto& entry : layerDiff.removed) {
+        renderLayers.erase(entry.first);
+    }
+
+    // Create render layers for newly added layers.
+    for (const auto& entry : layerDiff.added) {
+        renderLayers.emplace(entry.first, RenderLayer::create(entry.second));
+    }
+
+    // Update render layers for changed layers.
+    for (const auto& entry : layerDiff.changed) {
+        renderLayers.at(entry.first)->setImpl(entry.second.after);
+    }
+
+    // Update layers for class and zoom changes.
+    for (const auto& entry : renderLayers) {
+        RenderLayer& layer = *entry.second;
+        const bool layerAdded = layerDiff.added.count(entry.first);
+        const bool layerChanged = layerDiff.changed.count(entry.first);
+
+        if (layerAdded || layerChanged) {
+            layer.transition(transitionParameters);
+        }
+
+        if (layerAdded || layerChanged || zoomChanged || layer.hasTransition()) {
+            layer.evaluate(evaluationParameters);
+        }
+    }
+
+
+    const SourceDifference sourceDiff = diffSources(sourceImpls, updateParameters.sources);
+    sourceImpls = updateParameters.sources;
+
+    // Remove render layers for removed sources.
+    for (const auto& entry : sourceDiff.removed) {
+        renderSources.erase(entry.first);
+    }
+
+    // Create render sources for newly added sources.
+    for (const auto& entry : sourceDiff.added) {
+        std::unique_ptr<RenderSource> renderSource = RenderSource::create(entry.second);
+        renderSource->setObserver(this);
+        renderSources.emplace(entry.first, std::move(renderSource));
+    }
+
+    const bool hasImageDiff = !(imageDiff.added.empty() && imageDiff.removed.empty() && imageDiff.changed.empty());
+
+    // Update all sources.
+    for (const auto& source : *sourceImpls) {
+        std::vector<Immutable<Layer::Impl>> filteredLayers;
+        bool needsRendering = false;
+        bool needsRelayout = false;
+
+        for (const auto& layer : *layerImpls) {
+            if (layer->type == LayerType::Background ||
+                layer->type == LayerType::Custom ||
+                layer->source != source->id) {
+                continue;
+            }
+
+            if (!needsRendering && getRenderLayer(layer->id)->needsRendering(zoomHistory.lastZoom)) {
+                needsRendering = true;
+            }
+
+            if (!needsRelayout && (hasImageDiff || hasLayoutDifference(layerDiff, layer->id))) {
+                needsRelayout = true;
+            }
+
+            filteredLayers.push_back(layer);
+        }
+
+        renderSources.at(source->id)->update(source,
+                                             filteredLayers,
+                                             needsRendering,
+                                             needsRelayout,
+                                             tileParameters);
+    }
 
-    renderStyle->update(updateParameters);
     transformState = updateParameters.transformState;
 
     if (!staticData) {
@@ -63,60 +250,138 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         contextMode,
         backend,
         updateParameters,
-        *renderStyle,
+        renderLight.getEvaluated(),
         *staticData,
-        frameHistory
+        frameHistory,
+        *imageManager,
+        *lineAtlas
     };
 
-    bool loaded = updateParameters.styleLoaded && renderStyle->isLoaded();
+    bool loaded = updateParameters.styleLoaded && isLoaded();
+    if (updateParameters.mode == MapMode::Still && !loaded) {
+        return;
+    }
 
-    if (updateParameters.mode == MapMode::Continuous) {
-        if (renderState == RenderState::Never) {
-            observer->onWillStartRenderingMap();
-        }
+    if (renderState == RenderState::Never) {
+        observer->onWillStartRenderingMap();
+    }
+
+    observer->onWillStartRenderingFrame();
+
+    backend.updateAssumedState();
 
-        observer->onWillStartRenderingFrame();
+    if (parameters.contextMode == GLContextMode::Shared) {
+        parameters.context.setDirtyState();
+    }
 
-        backend.updateAssumedState();
+    Color backgroundColor;
 
-        doRender(parameters);
-        parameters.context.performCleanup();
+    class RenderItem {
+    public:
+        RenderLayer& layer;
+        RenderSource* source;
+    };
+
+    std::vector<RenderItem> order;
 
-        observer->onDidFinishRenderingFrame(
-                loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
-                renderStyle->hasTransitions() || frameHistory.needsAnimation(util::DEFAULT_TRANSITION_DURATION)
-        );
+    for (auto& layerImpl : *layerImpls) {
+        RenderLayer* layer = getRenderLayer(layerImpl->id);
+        assert(layer);
 
-        if (!loaded) {
-            renderState = RenderState::Partial;
-        } else if (renderState != RenderState::Fully) {
-            renderState = RenderState::Fully;
-            observer->onDidFinishRenderingMap();
+        if (!parameters.staticData.has3D && layer->is<RenderFillExtrusionLayer>()) {
+            parameters.staticData.has3D = true;
         }
-    } else if (loaded) {
-        observer->onWillStartRenderingMap();
-        observer->onWillStartRenderingFrame();
 
-        backend.updateAssumedState();
+        if (!layer->needsRendering(zoomHistory.lastZoom)) {
+            continue;
+        }
 
-        doRender(parameters);
+        if (const RenderBackgroundLayer* background = layer->as<RenderBackgroundLayer>()) {
+            const BackgroundPaintProperties::PossiblyEvaluated& paint = background->evaluated;
+            if (layerImpl.get() == layerImpls->at(0).get() && paint.get<BackgroundPattern>().from.empty()) {
+                // This is a solid background. We can use glClear().
+                backgroundColor = paint.get<BackgroundColor>() * paint.get<BackgroundOpacity>();
+            } else {
+                // This is a textured background, or not the bottommost layer. We need to render it with a quad.
+                order.emplace_back(RenderItem { *layer, nullptr });
+            }
+            continue;
+        }
 
-        observer->onDidFinishRenderingFrame(RendererObserver::RenderMode::Full, false);
-        observer->onDidFinishRenderingMap();
+        if (layer->is<RenderCustomLayer>()) {
+            order.emplace_back(RenderItem { *layer, nullptr });
+            continue;
+        }
 
-        // Cleanup only after signaling completion
-        parameters.context.performCleanup();
-    }
-}
+        RenderSource* source = getRenderSource(layer->baseImpl->source);
+        if (!source) {
+            Log::Warning(Event::Render, "can't find source for layer '%s'", layer->getID().c_str());
+            continue;
+        }
 
-void Renderer::Impl::doRender(PaintParameters& parameters) {
-    if (parameters.contextMode == GLContextMode::Shared) {
-        parameters.context.setDirtyState();
-    }
+        const bool symbolLayer = layer->is<RenderSymbolLayer>();
+
+        auto sortedTiles = source->getRenderTiles();
+        if (symbolLayer) {
+            // 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(sortedTiles.begin(), sortedTiles.end(), [&](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);
 
-    RenderData renderData = renderStyle->getRenderData(parameters.debugOptions, parameters.state.getAngle());
-    const std::vector<RenderItem>& order = renderData.order;
-    const std::unordered_set<RenderSource*>& sources = renderData.sources;
+                auto par = util::rotate(pa, parameters.state.getAngle());
+                auto pbr = util::rotate(pb, parameters.state.getAngle());
+
+                return std::tie(par.y, par.x) < std::tie(pbr.y, pbr.x);
+            });
+        } else {
+            std::sort(sortedTiles.begin(), sortedTiles.end(),
+                      [](const auto& a, const auto& b) { return a.get().id < b.get().id; });
+        }
+
+        std::vector<std::reference_wrapper<RenderTile>> sortedTilesForInsertion;
+        for (auto& sortedTile : sortedTiles) {
+            auto& tile = sortedTile.get();
+            if (!tile.tile.isRenderable()) {
+                continue;
+            }
+
+            // We're not clipping symbol layers, so when we have both parents and children of symbol
+            // layers, we drop all children in favor of their parent to avoid duplicate labels.
+            // See https://github.com/mapbox/mapbox-gl-native/issues/2482
+            if (symbolLayer) {
+                bool skip = false;
+                // Look back through the buckets we decided to render to find out whether there is
+                // already a bucket from this layer that is a parent of this tile. Tiles are ordered
+                // by zoom level when we obtain them from getTiles().
+                for (auto it = sortedTilesForInsertion.rbegin();
+                     it != sortedTilesForInsertion.rend(); ++it) {
+                    if (tile.tile.id.isChildOf(it->get().tile.id)) {
+                        skip = true;
+                        break;
+                    }
+                }
+                if (skip) {
+                    continue;
+                }
+            }
+
+            auto bucket = tile.tile.getBucket(*layer->baseImpl);
+            if (bucket) {
+                sortedTilesForInsertion.emplace_back(tile);
+                tile.used = true;
+
+                // We only need clipping when we're _not_ drawing a symbol layer. The only exception
+                // for symbol layers is when we're rendering still images. See render_symbol_layer.cpp
+                // for the exception we make there.
+                if (!symbolLayer || parameters.mapMode == MapMode::Still) {
+                    tile.needsClipping = true;
+                }
+            }
+        }
+        layer->setRenderTiles(std::move(sortedTilesForInsertion));
+        order.emplace_back(RenderItem { *layer, source });
+    }
 
     frameHistory.record(parameters.timePoint,
                         parameters.state.getZoom(),
@@ -130,6 +395,39 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
         parameters.imageManager.upload(parameters.context, 0);
         parameters.lineAtlas.upload(parameters.context, 0);
         parameters.frameHistory.upload(parameters.context, 0);
+
+        // Update all clipping IDs + upload buckets.
+        for (const auto& entry : renderSources) {
+            if (entry.second->isEnabled()) {
+                entry.second->startRender(parameters);
+            }
+        }
+    }
+
+    // - 3D PASS -------------------------------------------------------------------------------------
+    // Renders any 3D layers bottom-to-top to unique FBOs with texture attachments, but share the same
+    // depth rbo between them.
+    if (parameters.staticData.has3D) {
+        parameters.staticData.backendSize = parameters.backend.getFramebufferSize();
+
+        MBGL_DEBUG_GROUP(parameters.context, "3d");
+        parameters.pass = RenderPass::Pass3D;
+
+        if (!parameters.staticData.depthRenderbuffer ||
+            parameters.staticData.depthRenderbuffer->size != parameters.staticData.backendSize) {
+            parameters.staticData.depthRenderbuffer =
+                parameters.context.createRenderbuffer<gl::RenderbufferType::DepthComponent>(parameters.staticData.backendSize);
+        }
+        parameters.staticData.depthRenderbuffer->shouldClear(true);
+
+        uint32_t i = static_cast<uint32_t>(order.size()) - 1;
+        for (auto it = order.begin(); it != order.end(); ++it, --i) {
+            parameters.currentLayer = i;
+            if (it->layer.hasRenderPass(parameters.pass)) {
+                MBGL_DEBUG_GROUP(parameters.context, it->layer.getID());
+                it->layer.render(parameters, it->source);
+            }
+        }
     }
 
     // - CLEAR -------------------------------------------------------------------------------------
@@ -140,7 +438,7 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
         parameters.backend.bind();
         parameters.context.clear((parameters.debugOptions & MapDebugOptions::Overdraw)
                         ? Color::black()
-                        : renderData.backgroundColor,
+                        : backgroundColor,
                       1.0f,
                       0);
     }
@@ -148,13 +446,6 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
     // - CLIPPING MASKS ----------------------------------------------------------------------------
     // Draws the clipping masks to the stencil buffer.
     {
-        MBGL_DEBUG_GROUP(parameters.context, "clip");
-
-        // Update all clipping IDs.
-        for (const auto& source : sources) {
-            source->startRender(parameters);
-        }
-
         MBGL_DEBUG_GROUP(parameters.context, "clipping masks");
 
         static const style::FillPaintProperties::PossiblyEvaluated properties {};
@@ -220,10 +511,7 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
     }
 #endif
 
-    int indent = 0;
-
     // Actually render the layers
-    if (debug::renderTree) { Log::Info(Event::Render, "{"); indent++; }
 
     parameters.depthRangeSize = 1 - (order.size() + 2) * parameters.numSublayers * parameters.depthEpsilon;
 
@@ -233,10 +521,6 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
         parameters.pass = RenderPass::Opaque;
         MBGL_DEBUG_GROUP(parameters.context, "opaque");
 
-        if (debug::renderTree) {
-            Log::Info(Event::Render, "%*s%s {", indent++ * 4, "", "opaque");
-        }
-
         uint32_t i = 0;
         for (auto it = order.rbegin(); it != order.rend(); ++it, ++i) {
             parameters.currentLayer = i;
@@ -245,10 +529,6 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
                 it->layer.render(parameters, it->source);
             }
         }
-
-        if (debug::renderTree) {
-            Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}");
-        }
     }
 
     // - TRANSLUCENT PASS --------------------------------------------------------------------------
@@ -257,10 +537,6 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
         parameters.pass = RenderPass::Translucent;
         MBGL_DEBUG_GROUP(parameters.context, "translucent");
 
-        if (debug::renderTree) {
-            Log::Info(Event::Render, "%*s%s {", indent++ * 4, "", "translucent");
-        }
-
         uint32_t i = static_cast<uint32_t>(order.size()) - 1;
         for (auto it = order.begin(); it != order.end(); ++it, --i) {
             parameters.currentLayer = i;
@@ -269,14 +545,8 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
                 it->layer.render(parameters, it->source);
             }
         }
-
-        if (debug::renderTree) {
-            Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}");
-        }
     }
 
-    if (debug::renderTree) { Log::Info(Event::Render, "}"); indent--; }
-
     // - DEBUG PASS --------------------------------------------------------------------------------
     // Renders debug overlays.
     {
@@ -286,8 +556,10 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
         // This guarantees that we have at least one function per tile called.
         // When only rendering layers via the stylesheet, it's possible that we don't
         // ever visit a tile during rendering.
-        for (const auto& source : sources) {
-            source->finishRender(parameters);
+        for (const auto& entry : renderSources) {
+            if (entry.second->isEnabled()) {
+                entry.second->finishRender(parameters);
+            }
         }
     }
 
@@ -319,43 +591,159 @@ void Renderer::Impl::doRender(PaintParameters& parameters) {
     {
         MBGL_DEBUG_GROUP(parameters.context, "cleanup");
 
-        parameters.context.activeTexture = 1;
+        parameters.context.activeTextureUnit = 1;
         parameters.context.texture[1] = 0;
-        parameters.context.activeTexture = 0;
+        parameters.context.activeTextureUnit = 0;
         parameters.context.texture[0] = 0;
 
         parameters.context.bindVertexArray = 0;
     }
+
+    observer->onDidFinishRenderingFrame(
+        loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
+        updateParameters.mode == MapMode::Continuous && (hasTransitions() || frameHistory.needsAnimation(util::DEFAULT_TRANSITION_DURATION))
+    );
+
+    if (!loaded) {
+        renderState = RenderState::Partial;
+    } else if (renderState != RenderState::Fully) {
+        renderState = RenderState::Fully;
+        observer->onDidFinishRenderingMap();
+    }
+
+    // Cleanup only after signaling completion
+    parameters.context.performCleanup();
 }
 
 std::vector<Feature> Renderer::Impl::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options) const {
-    return renderStyle->queryRenderedFeatures(geometry, transformState, options);
+    std::vector<const RenderLayer*> layers;
+    if (options.layerIDs) {
+        for (const auto& layerID : *options.layerIDs) {
+            if (const RenderLayer* layer = getRenderLayer(layerID)) {
+                layers.emplace_back(layer);
+            }
+        }
+    } else {
+        for (const auto& entry : renderLayers) {
+            layers.emplace_back(entry.second.get());
+        }
+    }
+
+    std::unordered_set<std::string> sourceIDs;
+    for (const RenderLayer* layer : layers) {
+        sourceIDs.emplace(layer->baseImpl->source);
+    }
+
+    std::unordered_map<std::string, std::vector<Feature>> resultsByLayer;
+    for (const auto& sourceID : sourceIDs) {
+        if (RenderSource* renderSource = getRenderSource(sourceID)) {
+            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, layers, options);
+            std::move(sourceResults.begin(), sourceResults.end(), std::inserter(resultsByLayer, resultsByLayer.begin()));
+        }
+    }
+
+    std::vector<Feature> result;
+
+    if (resultsByLayer.empty()) {
+        return result;
+    }
+
+    // Combine all results based on the style layer order.
+    for (const auto& layerImpl : *layerImpls) {
+        const RenderLayer* layer = getRenderLayer(layerImpl->id);
+        if (!layer->needsRendering(zoomHistory.lastZoom)) {
+            continue;
+        }
+        auto it = resultsByLayer.find(layer->baseImpl->id);
+        if (it != resultsByLayer.end()) {
+            std::move(it->second.begin(), it->second.end(), std::back_inserter(result));
+        }
+    }
+
+    return result;
 }
 
 std::vector<Feature> Renderer::Impl::querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options) const {
-    const RenderSource* source = renderStyle->getRenderSource(sourceID);
+    const RenderSource* source = getRenderSource(sourceID);
     if (!source) return {};
 
     return source->querySourceFeatures(options);
 }
 
-void Renderer::Impl::onInvalidate() {
+void Renderer::Impl::onLowMemory() {
+    assert(BackendScope::exists());
+    backend.getContext().performCleanup();
+    for (const auto& entry : renderSources) {
+        entry.second->onLowMemory();
+    }
     observer->onInvalidate();
 }
 
-void Renderer::Impl::onResourceError(std::exception_ptr ptr) {
-    observer->onResourceError(ptr);
+void Renderer::Impl::dumDebugLogs() {
+    for (const auto& entry : renderSources) {
+        entry.second->dumpDebugLogs();
+    }
+
+    imageManager->dumpDebugLogs();
 }
 
-void Renderer::Impl::onLowMemory() {
-    BackendScope guard { backend };
-    backend.getContext().performCleanup();
-    renderStyle->onLowMemory();
-    observer->onInvalidate();
+RenderLayer* Renderer::Impl::getRenderLayer(const std::string& id) {
+    auto it = renderLayers.find(id);
+    return it != renderLayers.end() ? it->second.get() : nullptr;
 }
 
-void Renderer::Impl::dumDebugLogs() {
-    renderStyle->dumpDebugLogs();
+const RenderLayer* Renderer::Impl::getRenderLayer(const std::string& id) const {
+    auto it = renderLayers.find(id);
+    return it != renderLayers.end() ? it->second.get() : nullptr;
+}
+
+RenderSource* Renderer::Impl::getRenderSource(const std::string& id) const {
+    auto it = renderSources.find(id);
+    return it != renderSources.end() ? it->second.get() : nullptr;
+}
+
+bool Renderer::Impl::hasTransitions() const {
+    if (renderLight.hasTransition()) {
+        return true;
+    }
+
+    for (const auto& entry : renderLayers) {
+        if (entry.second->hasTransition()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool Renderer::Impl::isLoaded() const {
+    for (const auto& entry: renderSources) {
+        if (!entry.second->isLoaded()) {
+            return false;
+        }
+    }
+
+    if (!imageManager->isLoaded()) {
+        return false;
+    }
+
+    return true;
+}
+
+void Renderer::Impl::onGlyphsError(const FontStack& fontStack, const GlyphRange& glyphRange, std::exception_ptr error) {
+    Log::Error(Event::Style, "Failed to load glyph range %d-%d for font stack %s: %s",
+               glyphRange.first, glyphRange.second, fontStackToString(fontStack).c_str(), util::toString(error).c_str());
+    observer->onResourceError(error);
+}
+
+void Renderer::Impl::onTileError(RenderSource& source, const OverscaledTileID& tileID, std::exception_ptr error) {
+    Log::Error(Event::Style, "Failed to load tile %s for source %s: %s",
+               util::toString(tileID).c_str(), source.baseImpl->id.c_str(), util::toString(error).c_str());
+    observer->onResourceError(error);
+}
+
+void Renderer::Impl::onTileChanged(RenderSource&, const OverscaledTileID&) {
+    observer->onInvalidate();
 }
 
 } // namespace mbgl