Refactor RenderLayer and RenderSource to be more friendly for Non-tiled sources (#9058)

6 files changed, 66 insertions, 35 deletions

diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 3832403cce..a085f33c4b 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -13,6 +13,7 @@
 
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
 
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/renderer/layers/render_background_layer.hpp>
@@ -178,12 +179,7 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view) {
         frameHistory.upload(context, 0);
 
         for (const auto& item : order) {
-            for (const auto& tileRef : item.tiles) {
-                const auto& bucket = tileRef.get().tile.getBucket(*item.layer.baseImpl);
-                if (bucket && bucket->needsUpload()) {
-                    bucket->upload(context);
-                }
-            }
+            item.layer.uploadBuckets(context, item.source);
         }
     }
 
@@ -335,13 +331,7 @@ void Painter::renderPass(PaintParameters& parameters,
             context.setDepthMode(depthModeForSublayer(0, gl::DepthMode::ReadWrite));
             context.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, 1.0f, {});
 
-            for (auto& tileRef : item.tiles) {
-                auto& tile = tileRef.get();
-
-                MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - " + util::toString(tile.id));
-                auto bucket = tile.tile.getBucket(*layer.baseImpl);
-                bucket->render(*this, parameters, layer, tile);
-            }
+            renderItem(parameters, item);
 
             parameters.view.bind();
             context.bindTexture(extrusionTexture->getTexture());
@@ -363,12 +353,7 @@ void Painter::renderPass(PaintParameters& parameters,
                 ExtrusionTextureProgram::PaintPropertyBinders{ properties, 0 }, properties,
                 state.getZoom());
         } else {
-            for (auto& tileRef : item.tiles) {
-                auto& tile = tileRef.get();
-                MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - " + util::toString(tile.id));
-                auto bucket = tile.tile.getBucket(*layer.baseImpl);
-                bucket->render(*this, parameters, layer, tile);
-            }
+            renderItem(parameters, item);
         }
     }
 
@@ -377,6 +362,12 @@ void Painter::renderPass(PaintParameters& parameters,
     }
 }
 
+void Painter::renderItem(PaintParameters& parameters, const RenderItem& item) {
+    RenderLayer& layer = item.layer;
+    MBGL_DEBUG_GROUP(context, layer.getID());
+    layer.render(*this, parameters, item.source);
+}
+
 mat4 Painter::matrixForTile(const UnwrappedTileID& tileID) {
     mat4 matrix;
     state.matrixFor(matrix, tileID);
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index e2777134d0..5c3a8794a9 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -93,6 +93,8 @@ public:
     void renderRaster(PaintParameters&, RasterBucket&, const RenderRasterLayer&, const RenderTile&);
     void renderBackground(PaintParameters&, const RenderBackgroundLayer&);
 
+    void renderItem(PaintParameters&, const RenderItem&);
+
 #ifndef NDEBUG
     // Renders tile clip boundaries, using stencil buffer to calculate fill color.
     void renderClipMasks(PaintParameters&);
@@ -103,8 +105,6 @@ public:
     bool needsAnimation() const;
 
 private:
-    std::vector<RenderItem> determineRenderOrder(const style::Style&);
-
     template <class Iterator>
     void renderPass(PaintParameters&,
                     RenderPass,
diff --git a/src/mbgl/renderer/render_item.hpp b/src/mbgl/renderer/render_item.hpp
index 787211c30a..4bf5629263 100644
--- a/src/mbgl/renderer/render_item.hpp
+++ b/src/mbgl/renderer/render_item.hpp
@@ -17,13 +17,13 @@ namespace style {
 
 class RenderItem {
 public:
-    RenderItem(const RenderLayer& layer_,
-               std::vector<std::reference_wrapper<RenderTile>> tiles_ = {})
-        : layer(layer_), tiles(std::move(tiles_)) {
+    RenderItem(RenderLayer& layer_,
+               RenderSource* renderSource_)
+        : layer(layer_), source(renderSource_) {
     }
 
-    const RenderLayer& layer;
-    std::vector<std::reference_wrapper<RenderTile>> tiles;
+    RenderLayer& layer;
+    RenderSource* source;
 };
 
 class RenderData {
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index cf7f772e16..4bffb87cf1 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -8,6 +8,8 @@
 #include <mbgl/renderer/layers/render_raster_layer.hpp>
 #include <mbgl/renderer/layers/render_symbol_layer.hpp>
 #include <mbgl/style/types.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/tile/tile.hpp>
 
 namespace mbgl {
 
@@ -62,4 +64,27 @@ bool RenderLayer::needsRendering(float zoom) const {
            && baseImpl->maxZoom >= zoom;
 }
 
-} // namespace mbgl
+void RenderLayer::setRenderTiles(std::vector<std::reference_wrapper<RenderTile>> tiles) {
+    renderTiles = std::move(tiles);
+}
+
+void RenderLayer::uploadBuckets(gl::Context& context, RenderSource*) {
+    for (const auto& tileRef : renderTiles) {
+        const auto& bucket = tileRef.get().tile.getBucket(*baseImpl);
+        if (bucket && bucket->needsUpload()) {
+            bucket->upload(context);
+        }
+    }
+}
+
+void RenderLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
+    for (auto& tileRef : renderTiles) {
+        auto& tile = tileRef.get();
+        auto bucket = tile.tile.getBucket(*baseImpl);
+        bucket->render(painter, parameters, *this, tile);
+    }
+}
+
+
+} //namespace mbgl
+
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 263e0039fa..ce71794c07 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -14,6 +14,14 @@ class Bucket;
 class BucketParameters;
 class TransitionParameters;
 class PropertyEvaluationParameters;
+class Painter;
+class PaintParameters;
+class RenderSource;
+class RenderTile;
+
+namespace gl {
+class Context;
+}   // namespace gl
 
 class RenderLayer {
 protected:
@@ -58,6 +66,8 @@ public:
     // Checks whether this layer can be rendered.
     bool needsRendering(float zoom) const;
 
+    virtual void uploadBuckets(gl::Context&, RenderSource* source);
+    virtual void render(Painter& , PaintParameters& , RenderSource* source);
     // Check wether the given geometry intersects
     // with the feature
     virtual bool queryIntersectsFeature(
@@ -69,6 +79,7 @@ public:
 
     virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const = 0;
 
+    void setRenderTiles(std::vector<std::reference_wrapper<RenderTile>>);
     // Private implementation
     Immutable<style::Layer::Impl> baseImpl;
     void setImpl(Immutable<style::Layer::Impl>);
@@ -79,6 +90,10 @@ protected:
     // Stores what render passes this layer is currently enabled for. This depends on the
     // evaluated StyleProperties object and is updated accordingly.
     RenderPass passes = RenderPass::None;
+
+    //Stores current set of tiles to be rendered for this layer.
+    std::vector<std::reference_wrapper<RenderTile>> renderTiles;
+
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 9445772a66..e75925f476 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -535,8 +535,8 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
         }
     }
 
-    for (const auto& layerImpl : layerImpls) {
-        const RenderLayer* layer = getRenderLayer(layerImpl->id);
+    for (auto& layerImpl : layerImpls) {
+        RenderLayer* layer = getRenderLayer(layerImpl->id);
         assert(layer);
 
         if (!layer->needsRendering(zoomHistory.lastZoom)) {
@@ -546,7 +546,7 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
         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);
+                result.order.emplace_back(*layer, nullptr);
                 continue;
             }
             const BackgroundPaintProperties::PossiblyEvaluated& paint = background->evaluated;
@@ -555,19 +555,19 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
                 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);
+                result.order.emplace_back(*layer, nullptr);
             }
             continue;
         }
 
         if (layer->is<RenderCustomLayer>()) {
-            result.order.emplace_back(*layer);
+            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->baseImpl->id.c_str());
+            Log::Warning(Event::Render, "can't find source for layer '%s'", layer->getID().c_str());
             continue;
         }
 
@@ -626,8 +626,8 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
                 tile.used = true;
             }
         }
-
-        result.order.emplace_back(*layer, std::move(sortedTilesForInsertion));
+        layer->setRenderTiles(std::move(sortedTilesForInsertion));
+        result.order.emplace_back(*layer, source);
     }
 
     return result;