17 files changed, 580 insertions, 31 deletions

diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index a085f33c4b..6fb325db40 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/render_style.hpp>
 
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/source_impl.hpp>
@@ -11,7 +12,6 @@
 #include <mbgl/util/logging.hpp>
 #include <mbgl/gl/debugging.hpp>
 
-#include <mbgl/style/style.hpp>
 #include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/layers/custom_layer_impl.hpp>
 
@@ -126,7 +126,7 @@ void Painter::cleanup() {
     context.performCleanup();
 }
 
-void Painter::render(const Style& style, const FrameData& frame_, View& view) {
+void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
     frame = frame_;
     if (frame.contextMode == GLContextMode::Shared) {
         context.setDirtyState();
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index e361b0f7d7..fddaff6318 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -7,6 +7,7 @@
 #include <mbgl/renderer/frame_history.hpp>
 #include <mbgl/renderer/render_item.hpp>
 #include <mbgl/renderer/bucket.hpp>
+#include <mbgl/renderer/render_light.hpp>
 
 #include <mbgl/gl/context.hpp>
 #include <mbgl/programs/debug_program.hpp>
@@ -15,8 +16,6 @@
 #include <mbgl/programs/extrusion_texture_program.hpp>
 #include <mbgl/programs/raster_program.hpp>
 
-#include <mbgl/style/style.hpp>
-
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/util/constants.hpp>
@@ -29,6 +28,7 @@
 
 namespace mbgl {
 
+class RenderStyle;
 class RenderTile;
 class SpriteAtlas;
 class View;
@@ -59,11 +59,6 @@ class TilePyramid;
 
 struct ClipID;
 
-namespace style {
-class Style;
-class Source;
-} // namespace style
-
 struct FrameData {
     TimePoint timePoint;
     float pixelRatio;
@@ -77,7 +72,7 @@ public:
     Painter(gl::Context&, const TransformState&, float pixelRatio, const std::string& programCacheDir);
     ~Painter();
 
-    void render(const style::Style&,
+    void render(RenderStyle&,
                 const FrameData&,
                 View&);
 
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index b229d8a0bd..b396a0fdb6 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -18,6 +18,7 @@ namespace mbgl {
 class Painter;
 class TransformState;
 class RenderTile;
+class RenderStyle;
 class RenderLayer;
 class RenderedQueryOptions;
 class SourceQueryOptions;
@@ -25,10 +26,6 @@ class Tile;
 class RenderSourceObserver;
 class TileParameters;
 
-namespace style {
-class Style;
-} // namespace style
-
 namespace algorithm {
 class ClipIDGenerator;
 } // namespace algorithm
@@ -72,7 +69,7 @@ public:
     virtual std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const = 0;
 
     virtual std::vector<Feature>
diff --git a/src/mbgl/renderer/render_style.cpp b/src/mbgl/renderer/render_style.cpp
new file mode 100644
index 0000000000..a3a7d57527
--- /dev/null
+++ b/src/mbgl/renderer/render_style.cpp
@@ -0,0 +1,445 @@
+#include <mbgl/renderer/render_style.hpp>
+#include <mbgl/renderer/render_style_observer.hpp>
+#include <mbgl/renderer/update_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_source.hpp>
+#include <mbgl/renderer/render_item.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/layers/render_background_layer.hpp>
+#include <mbgl/renderer/layers/render_circle_layer.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
+#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
+#include <mbgl/renderer/layers/render_fill_layer.hpp>
+#include <mbgl/renderer/layers/render_line_layer.hpp>
+#include <mbgl/renderer/layers/render_raster_layer.hpp>
+#include <mbgl/renderer/layers/render_symbol_layer.hpp>
+#include <mbgl/renderer/style_diff.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/transition_options.hpp>
+#include <mbgl/sprite/sprite_atlas.hpp>
+#include <mbgl/sprite/sprite_loader.hpp>
+#include <mbgl/text/glyph_atlas.hpp>
+#include <mbgl/geometry/line_atlas.hpp>
+#include <mbgl/sprite/sprite_atlas.hpp>
+#include <mbgl/map/query.hpp>
+#include <mbgl/tile/tile.hpp>
+#include <mbgl/util/math.hpp>
+#include <mbgl/util/string.hpp>
+
+namespace mbgl {
+
+using namespace style;
+
+RenderStyleObserver nullObserver;
+
+RenderStyle::RenderStyle(Scheduler& scheduler_, FileSource& fileSource_)
+    : scheduler(scheduler_),
+      fileSource(fileSource_),
+      glyphAtlas(std::make_unique<GlyphAtlas>(Size{ 2048, 2048 }, fileSource)),
+      spriteAtlas(std::make_unique<SpriteAtlas>()),
+      lineAtlas(std::make_unique<LineAtlas>(Size{ 256, 512 })),
+      renderLight(makeMutable<Light::Impl>()),
+      observer(&nullObserver) {
+    glyphAtlas->setObserver(this);
+}
+
+RenderStyle::~RenderStyle() = default;
+
+void RenderStyle::setObserver(RenderStyleObserver* observer_) {
+    observer = observer_;
+}
+
+std::vector<const RenderLayer*> RenderStyle::getRenderLayers() const {
+    std::vector<const RenderLayer*> result;
+    result.reserve(renderLayers.size());
+    for (const auto& layer : layerImpls) {
+        result.push_back(getRenderLayer(layer->id));
+    }
+    return result;
+}
+
+RenderLayer* RenderStyle::getRenderLayer(const std::string& id) {
+    auto it = renderLayers.find(id);
+    return it != renderLayers.end() ? it->second.get() : nullptr;
+}
+
+const RenderLayer* RenderStyle::getRenderLayer(const std::string& id) const {
+    auto it = renderLayers.find(id);
+    return it != renderLayers.end() ? it->second.get() : nullptr;
+}
+
+const RenderLight& RenderStyle::getRenderLight() const {
+    return renderLight;
+}
+
+void RenderStyle::update(const UpdateParameters& parameters) {
+    const bool zoomChanged = zoomHistory.update(parameters.transformState.getZoom(), parameters.timePoint);
+
+    const TransitionParameters transitionParameters {
+        parameters.mode == MapMode::Continuous ? parameters.timePoint : Clock::time_point::max(),
+        parameters.mode == MapMode::Continuous ? parameters.transitionOptions : TransitionOptions()
+    };
+
+    const PropertyEvaluationParameters evaluationParameters {
+        zoomHistory,
+        parameters.mode == MapMode::Continuous ? parameters.timePoint : Clock::time_point::max(),
+        parameters.mode == MapMode::Continuous ? util::DEFAULT_FADE_DURATION : Duration::zero()
+    };
+
+    const TileParameters tileParameters {
+        parameters.pixelRatio,
+        parameters.debugOptions,
+        parameters.transformState,
+        parameters.scheduler,
+        parameters.fileSource,
+        parameters.mode,
+        parameters.annotationManager,
+        *spriteAtlas,
+        *glyphAtlas
+    };
+
+    glyphAtlas->setURL(parameters.glyphURL);
+
+    // Update light.
+    const bool lightChanged = renderLight.impl != parameters.light;
+
+    if (lightChanged) {
+        renderLight.impl = parameters.light;
+        renderLight.transition(transitionParameters);
+    }
+
+    if (lightChanged || zoomChanged || renderLight.hasTransition()) {
+        renderLight.evaluate(evaluationParameters);
+    }
+
+
+    const ImageDifference imageDiff = diffImages(imageImpls, parameters.images);
+    imageImpls = parameters.images;
+
+    // Remove removed images from sprite atlas.
+    for (const auto& entry : imageDiff.removed) {
+        spriteAtlas->removeImage(entry.first);
+    }
+
+    // Add added images to sprite atlas.
+    for (const auto& entry : imageDiff.added) {
+        spriteAtlas->addImage(entry.second);
+    }
+
+    // Update changed images.
+    for (const auto& entry : imageDiff.changed) {
+        spriteAtlas->updateImage(entry.second[1]);
+    }
+
+    if (parameters.spriteLoaded && !spriteAtlas->isLoaded()) {
+        spriteAtlas->onSpriteLoaded();
+    }
+
+
+    const LayerDifference layerDiff = diffLayers(layerImpls, parameters.layers);
+    layerImpls = parameters.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[1]);
+    }
+
+    // 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, parameters.sources);
+    sourceImpls = parameters.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));
+    }
+
+    // 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 (getRenderLayer(layer->id)->needsRendering(zoomHistory.lastZoom)) {
+                needsRendering = true;
+            }
+
+            if (hasLayoutDifference(layerDiff, layer->id)) {
+                needsRelayout = true;
+            }
+
+            filteredLayers.push_back(layer);
+        }
+
+        renderSources.at(source->id)->update(source,
+                                             filteredLayers,
+                                             needsRendering,
+                                             needsRelayout,
+                                             tileParameters);
+    }
+}
+
+RenderSource* RenderStyle::getRenderSource(const std::string& id) const {
+    auto it = renderSources.find(id);
+    return it != renderSources.end() ? it->second.get() : nullptr;
+}
+
+bool RenderStyle::hasTransitions() const {
+    if (renderLight.hasTransition()) {
+        return true;
+    }
+
+    for (const auto& entry : renderLayers) {
+        if (entry.second->hasTransition()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool RenderStyle::isLoaded() const {
+    for (const auto& entry: renderSources) {
+        if (!entry.second->isLoaded()) {
+            return false;
+        }
+    }
+
+    if (!spriteAtlas->isLoaded()) {
+        return false;
+    }
+
+    return true;
+}
+
+RenderData RenderStyle::getRenderData(MapDebugOptions debugOptions, float angle) {
+    RenderData result;
+
+    for (const auto& entry : renderSources) {
+        if (entry.second->isEnabled()) {
+            result.sources.insert(entry.second.get());
+        }
+    }
+
+    for (auto& layerImpl : layerImpls) {
+        RenderLayer* layer = getRenderLayer(layerImpl->id);
+        assert(layer);
+
+        if (!layer->needsRendering(zoomHistory.lastZoom)) {
+            continue;
+        }
+
+        if (const RenderBackgroundLayer* background = layer->as<RenderBackgroundLayer>()) {
+            if (debugOptions & MapDebugOptions::Overdraw) {
+                // We want to skip glClear optimization in overdraw mode.
+                result.order.emplace_back(*layer, nullptr);
+                continue;
+            }
+            const BackgroundPaintProperties::PossiblyEvaluated& paint = background->evaluated;
+            if (layerImpl.get() == layerImpls[0].get() && paint.get<BackgroundPattern>().from.empty()) {
+                // This is a solid background. We can use glClear().
+                result.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.
+                result.order.emplace_back(*layer, nullptr);
+            }
+            continue;
+        }
+
+        if (layer->is<RenderCustomLayer>()) {
+            result.order.emplace_back(*layer, nullptr);
+            continue;
+        }
+
+        RenderSource* source = getRenderSource(layer->baseImpl->source);
+        if (!source) {
+            Log::Warning(Event::Render, "can't find source for layer '%s'", layer->getID().c_str());
+            continue;
+        }
+
+        auto& renderTiles = source->getRenderTiles();
+        const bool symbolLayer = layer->is<RenderSymbolLayer>();
+
+        // 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::vector<std::reference_wrapper<RenderTile>> sortedTiles;
+        std::transform(renderTiles.begin(), renderTiles.end(), std::back_inserter(sortedTiles),
+                [](auto& pair) { return std::ref(pair.second); });
+        if (symbolLayer) {
+            std::sort(sortedTiles.begin(), sortedTiles.end(),
+                      [angle](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, angle);
+                auto pbr = util::rotate(pb, angle);
+
+                return std::tie(par.y, par.x) < std::tie(pbr.y, pbr.x);
+            });
+        }
+
+        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;
+            }
+        }
+        layer->setRenderTiles(std::move(sortedTilesForInsertion));
+        result.order.emplace_back(*layer, source);
+    }
+
+    return result;
+}
+
+std::vector<Feature> RenderStyle::queryRenderedFeatures(const ScreenLineString& geometry,
+                                                  const TransformState& transformState,
+                                                  const RenderedQueryOptions& options) const {
+    std::unordered_map<std::string, std::vector<Feature>> resultsByLayer;
+
+    if (options.layerIDs) {
+        std::unordered_set<std::string> sourceIDs;
+        for (const auto& layerID : *options.layerIDs) {
+            if (const RenderLayer* layer = getRenderLayer(layerID)) {
+                sourceIDs.emplace(layer->baseImpl->source);
+            }
+        }
+        for (const auto& sourceID : sourceIDs) {
+            if (RenderSource* renderSource = getRenderSource(sourceID)) {
+                auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, *this, options);
+                std::move(sourceResults.begin(), sourceResults.end(), std::inserter(resultsByLayer, resultsByLayer.begin()));
+            }
+        }
+    } else {
+        for (const auto& entry : renderSources) {
+            auto sourceResults = entry.second->queryRenderedFeatures(geometry, transformState, *this, 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;
+}
+
+void RenderStyle::setSourceTileCacheSize(size_t size) {
+    for (const auto& entry : renderSources) {
+        entry.second->setCacheSize(size);
+    }
+}
+
+void RenderStyle::onLowMemory() {
+    for (const auto& entry : renderSources) {
+        entry.second->onLowMemory();
+    }
+}
+
+void RenderStyle::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 RenderStyle::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 RenderStyle::onTileChanged(RenderSource&, const OverscaledTileID&) {
+    observer->onInvalidate();
+}
+
+void RenderStyle::dumpDebugLogs() const {
+    for (const auto& entry : renderSources) {
+        entry.second->dumpDebugLogs();
+    }
+
+    spriteAtlas->dumpDebugLogs();
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/render_style.hpp b/src/mbgl/renderer/render_style.hpp
new file mode 100644
index 0000000000..ff03b48fdf
--- /dev/null
+++ b/src/mbgl/renderer/render_style.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <mbgl/style/image.hpp>
+#include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/render_source_observer.hpp>
+#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/renderer/render_light.hpp>
+#include <mbgl/text/glyph_atlas_observer.hpp>
+#include <mbgl/map/zoom_history.hpp>
+#include <mbgl/map/mode.hpp>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mbgl {
+
+class FileSource;
+class GlyphAtlas;
+class SpriteAtlas;
+class LineAtlas;
+class RenderData;
+class TransformState;
+class RenderedQueryOptions;
+class Scheduler;
+class UpdateParameters;
+class RenderStyleObserver;
+
+namespace style {
+class Image;
+class Source;
+class Layer;
+} // namespace style
+
+class RenderStyle : public GlyphAtlasObserver,
+                    public RenderSourceObserver {
+public:
+    RenderStyle(Scheduler&, FileSource&);
+    ~RenderStyle() final;
+
+    void setObserver(RenderStyleObserver*);
+    void update(const UpdateParameters&);
+
+    bool isLoaded() const;
+    bool hasTransitions() const;
+
+    RenderSource* getRenderSource(const std::string& id) const;
+
+    std::vector<const RenderLayer*> getRenderLayers() const;
+
+          RenderLayer* getRenderLayer(const std::string& id);
+    const RenderLayer* getRenderLayer(const std::string& id) const;
+
+    const RenderLight& getRenderLight() const;
+
+    RenderData getRenderData(MapDebugOptions, float angle);
+
+    std::vector<Feature> queryRenderedFeatures(const ScreenLineString& geometry,
+                                               const TransformState& transformState,
+                                               const RenderedQueryOptions& options) const;
+
+    void setSourceTileCacheSize(size_t);
+    void onLowMemory();
+
+    void dumpDebugLogs() const;
+
+    Scheduler& scheduler;
+    FileSource& fileSource;
+    std::unique_ptr<GlyphAtlas> glyphAtlas;
+    std::unique_ptr<SpriteAtlas> spriteAtlas;
+    std::unique_ptr<LineAtlas> lineAtlas;
+
+private:
+    std::vector<Immutable<style::Image::Impl>> imageImpls;
+    std::vector<Immutable<style::Source::Impl>> sourceImpls;
+    std::vector<Immutable<style::Layer::Impl>> layerImpls;
+
+    std::unordered_map<std::string, std::unique_ptr<RenderSource>> renderSources;
+    std::unordered_map<std::string, std::unique_ptr<RenderLayer>> renderLayers;
+    RenderLight renderLight;
+
+    // GlyphAtlasObserver implementation.
+    void onGlyphsError(const FontStack&, const GlyphRange&, std::exception_ptr) override;
+
+    // RenderSourceObserver implementation.
+    void onTileChanged(RenderSource&, const OverscaledTileID&) override;
+    void onTileError(RenderSource&, const OverscaledTileID&, std::exception_ptr) override;
+
+    RenderStyleObserver* observer;
+    ZoomHistory zoomHistory;
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/render_style_observer.hpp b/src/mbgl/renderer/render_style_observer.hpp
new file mode 100644
index 0000000000..5852dd68b8
--- /dev/null
+++ b/src/mbgl/renderer/render_style_observer.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <exception>
+
+namespace mbgl {
+
+class RenderStyleObserver {
+public:
+    virtual ~RenderStyleObserver() = default;
+    virtual void onInvalidate() {}
+    virtual void onResourceError(std::exception_ptr) {}
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index 19e93ca2ba..96500d8fae 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -74,7 +74,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderGeoJSONSource::getRenderTiles() {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderGeoJSONSource::queryRenderedFeatures(const ScreenLineString& geometry,
                                            const TransformState& transformState,
-                                           const style::Style& style,
+                                           const RenderStyle& style,
                                            const RenderedQueryOptions& options) const {
     return tilePyramid.queryRenderedFeatures(geometry, transformState, style, options);
 }
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index c3783af642..2683ef9d21 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -33,7 +33,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const final;
 
     std::vector<Feature>
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 5f9887cdb8..ffa8e6bb5e 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -57,7 +57,7 @@ void RenderImageSource::finishRender(Painter& painter) {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderImageSource::queryRenderedFeatures(const ScreenLineString&,
                                          const TransformState&,
-                                         const style::Style&,
+                                         const RenderStyle&,
                                          const RenderedQueryOptions&) const {
     return {};
 }
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index dc5c32876b..c4685cf891 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -43,7 +43,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const final;
 
     std::vector<Feature> querySourceFeatures(const SourceQueryOptions&) const final;
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index 239bac9dd6..81a9771676 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -71,7 +71,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderRasterSource::getRenderTiles() {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderRasterSource::queryRenderedFeatures(const ScreenLineString&,
                                           const TransformState&,
-                                          const style::Style&,
+                                          const RenderStyle&,
                                           const RenderedQueryOptions&) const {
     return {};
 }
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index cbe16b967e..9209a5ca65 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -29,7 +29,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const final;
 
     std::vector<Feature>
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 869d87b0b7..30014a89dc 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -75,7 +75,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderVectorSource::getRenderTiles() {
 std::unordered_map<std::string, std::vector<Feature>>
 RenderVectorSource::queryRenderedFeatures(const ScreenLineString& geometry,
                                           const TransformState& transformState,
-                                          const style::Style& style,
+                                          const RenderStyle& style,
                                           const RenderedQueryOptions& options) const {
     return tilePyramid.queryRenderedFeatures(geometry, transformState, style, options);
 }
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index c1357141a6..1f1acdd551 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -29,7 +29,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const final;
 
     std::vector<Feature>
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index 7d9d7c88ca..184bafc204 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -186,7 +186,7 @@ void TilePyramid::removeStaleTiles(const std::set<OverscaledTileID>& retain) {
 
 std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRenderedFeatures(const ScreenLineString& geometry,
                                            const TransformState& transformState,
-                                           const style::Style& style,
+                                           const RenderStyle& style,
                                            const RenderedQueryOptions& options) const {
     std::unordered_map<std::string, std::vector<Feature>> result;
     if (renderTiles.empty() || geometry.empty()) {
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index b99c94d065..d989306414 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -21,14 +21,11 @@ namespace mbgl {
 class Painter;
 class TransformState;
 class RenderTile;
+class RenderStyle;
 class RenderedQueryOptions;
 class SourceQueryOptions;
 class TileParameters;
 
-namespace style {
-class Style;
-} // namespace style
-
 class TilePyramid {
 public:
     TilePyramid();
@@ -55,7 +52,7 @@ public:
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
-                          const style::Style& style,
+                          const RenderStyle& style,
                           const RenderedQueryOptions& options) const;
 
     std::vector<Feature> querySourceFeatures(const SourceQueryOptions&) const;
diff --git a/src/mbgl/renderer/update_parameters.hpp b/src/mbgl/renderer/update_parameters.hpp
index ae54ac09e7..6e78acfa07 100644
--- a/src/mbgl/renderer/update_parameters.hpp
+++ b/src/mbgl/renderer/update_parameters.hpp
@@ -13,14 +13,22 @@ class AnnotationManager;
 class UpdateParameters {
 public:
     const MapMode mode;
-    const Update updateFlags;
     const float pixelRatio;
     const MapDebugOptions debugOptions;
     const TimePoint timePoint;
-    const TransformState& transformState;
+
+    const std::string glyphURL;
+    const bool spriteLoaded;
+    const style::TransitionOptions transitionOptions;
+    const Immutable<style::Light::Impl> light;
+    const std::vector<Immutable<style::Image::Impl>> images;
+    const std::vector<Immutable<style::Source::Impl>> sources;
+    const std::vector<Immutable<style::Layer::Impl>> layers;
+
     Scheduler& scheduler;
     FileSource& fileSource;
     AnnotationManager& annotationManager;
+    const TransformState& transformState;
 };
 
 } // namespace mbgl