[core] Introduce LayerRenderItem

3 files changed, 75 insertions, 19 deletions

diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index 821b10050f..396fc64b2d 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -12,6 +12,33 @@ namespace mbgl {
 
 using namespace style;
 
+LayerRenderItem::LayerRenderItem(RenderTiles renderTiles_, LayerRenderer renderer_, LayerUploader uploader_, Immutable<style::LayerProperties> evaluatedProperties_, RenderPass renderPass_)
+    : renderTiles(std::move(renderTiles_))
+    , renderer(std::move(renderer_))
+    , uploader(std::move(uploader_))
+    , evaluatedProperties(std::move(evaluatedProperties_))
+    , renderPass(renderPass_) {}
+
+LayerRenderItem::~LayerRenderItem() = default;
+
+LayerRenderItem RenderLayer::createRenderItem() {
+    return {
+        renderTiles,
+        createRenderer(),
+        createUploader(),
+        evaluatedProperties,
+        passes
+    };
+}
+
+LayerRenderer RenderLayer::createRenderer() {
+    return [this](PaintParameters& pass, const LayerRenderItem&){ render(pass); };
+}
+
+LayerUploader RenderLayer::createUploader() {
+    return [this](gfx::UploadPass& pass){ upload(pass); };
+}
+
 RenderLayer::RenderLayer(Immutable<style::LayerProperties> properties)
     : evaluatedProperties(std::move(properties)),
       baseImpl(evaluatedProperties->baseImpl) {
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 11c7587893..6837d22072 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -1,10 +1,12 @@
 #pragma once
 #include <mbgl/layout/layout.hpp>
 #include <mbgl/renderer/render_pass.hpp>
+#include <mbgl/renderer/render_tree.hpp>
 #include <mbgl/style/layer_properties.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/util/mat4.hpp>
 
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -43,7 +45,31 @@ public:
     const TransformState& state;
 };
 
+class LayerRenderItem;
 using RenderTiles = std::vector<std::reference_wrapper<const RenderTile>>;
+using LayerUploader = std::function<void(gfx::UploadPass&)>;
+using LayerRenderer = std::function<void(PaintParameters&, const LayerRenderItem&)>;
+
+class LayerRenderItem final : public RenderItem {
+public:
+    LayerRenderItem(RenderTiles, LayerRenderer, LayerUploader, Immutable<style::LayerProperties>, RenderPass);
+    ~LayerRenderItem();
+
+    RenderTiles renderTiles;
+    LayerRenderer renderer;
+    LayerUploader uploader; // optionally initialized.
+    Immutable<style::LayerProperties> evaluatedProperties;
+
+private:
+    bool hasRenderPass(RenderPass pass) const override { return bool(renderPass & pass); }
+    void upload(gfx::UploadPass& pass) const override { if (uploader) uploader(pass);}
+    void render(PaintParameters& parameters) const override {
+        assert(renderer);
+        renderer(parameters, *this);
+    }
+    const std::string& getName() const override { return evaluatedProperties->baseImpl->id; } 
+    RenderPass renderPass;
+};
 
 class RenderLayer {
 protected:
@@ -52,6 +78,7 @@ protected:
 public:
     virtual ~RenderLayer() = default;
 
+    LayerRenderItem createRenderItem();
     // Begin transitions for any properties that have changed since the last frame.
     virtual void transition(const TransitionParameters&) = 0;
 
@@ -112,6 +139,8 @@ public:
     virtual optional<Color> getSolidBackground() const;
 
 protected:
+    virtual LayerRenderer createRenderer();
+    virtual LayerUploader createUploader();
     // Checks whether the current hardware can render this layer. If it can't, we'll show a warning
     // in the console to inform the developer.
     void checkRenderability(const PaintParameters&, uint32_t activeBindingCount);
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index fafbc8b635..57a9eba954 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -38,27 +38,20 @@ static RendererObserver& nullObserver() {
 
 namespace {
 
-class LayerRenderItem final : public RenderItem {
+class OrderedRenderLayerItem {
 public:
-    LayerRenderItem(RenderLayer& layer_, RenderSource* source_, uint32_t index_)
+    OrderedRenderLayerItem(RenderLayer& layer_, RenderSource* source_, uint32_t index_)
         : layer(layer_), source(source_), index(index_) {}
-    bool operator<(const LayerRenderItem& other) const { return index < other.index; }
+    bool operator<(const OrderedRenderLayerItem& other) const { return index < other.index; }
     std::reference_wrapper<RenderLayer> layer;
     RenderSource* source;
-
-private:
-    bool hasRenderPass(RenderPass pass) const override { return layer.get().hasRenderPass(pass); }
-    void upload(gfx::UploadPass& pass) const override { layer.get().upload(pass); }
-    void render(PaintParameters& parameters) const override { layer.get().render(parameters); }
-    const std::string& getName() const override { return layer.get().getID(); } 
-
     uint32_t index;
 };
 
 class RenderTreeImpl final : public RenderTree {
 public:
     RenderTreeImpl(std::unique_ptr<RenderTreeParameters> parameters_,
-                   std::set<LayerRenderItem> layerRenderItems_,
+                   std::vector<LayerRenderItem> layerRenderItems_,
                    std::vector<std::unique_ptr<RenderItem>> sourceRenderItems_,
                    LineAtlas& lineAtlas_,
                    PatternAtlas& patternAtlas_)
@@ -81,7 +74,7 @@ public:
     LineAtlas& getLineAtlas() const override { return lineAtlas; }
     PatternAtlas& getPatternAtlas() const override { return patternAtlas; }
 
-    std::set<LayerRenderItem> layerRenderItems;
+    std::vector<LayerRenderItem> layerRenderItems;
     std::vector<std::unique_ptr<RenderItem>> sourceRenderItems;
     std::reference_wrapper<LineAtlas> lineAtlas;
     std::reference_wrapper<PatternAtlas> patternAtlas;
@@ -267,9 +260,9 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         updateParameters.timePoint,
         renderLight.getEvaluated());
 
-    std::set<LayerRenderItem> layerRenderItems;
+    std::set<OrderedRenderLayerItem> orderedRenderLayers;
     std::vector<std::reference_wrapper<RenderLayer>> layersNeedPlacement;
-    auto renderItemsEmplaceHint = layerRenderItems.begin();
+    auto emplaceHint = orderedRenderLayers.begin();
 
     // Update all sources and initialize renderItems.
     for (const auto& sourceImpl : *sourceImpls) {
@@ -297,7 +290,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
                         filteredLayersForSource.push_back(layer->evaluatedProperties);
                         if (zoomFitsLayer) {
                             sourceNeedsRendering = true;
-                            renderItemsEmplaceHint = layerRenderItems.emplace_hint(renderItemsEmplaceHint, *layer, source, index);
+                            emplaceHint = orderedRenderLayers.emplace_hint(emplaceHint, *layer, source, index);
                         }
                     }
                 }
@@ -313,7 +306,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
                         continue; // This layer is shown with background color, and it shall not be added to render items. 
                     }
                 }
-                renderItemsEmplaceHint = layerRenderItems.emplace_hint(renderItemsEmplaceHint, *layer, nullptr, index);
+                emplaceHint = orderedRenderLayers.emplace_hint(emplaceHint, *layer, nullptr, index);
             }
         }
         source->update(sourceImpl,
@@ -335,9 +328,9 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         }
     }
 
-    for (auto& renderItem : layerRenderItems) {
-        RenderLayer& renderLayer = renderItem.layer;
-        renderLayer.prepare({renderItem.source, *imageManager, *patternAtlas, *lineAtlas, updateParameters.transformState});
+    for (auto& entry : orderedRenderLayers) {
+        RenderLayer& renderLayer = entry.layer;
+        renderLayer.prepare({entry.source, *imageManager, *patternAtlas, *lineAtlas, updateParameters.transformState});
         if (renderLayer.needsPlacement()) {
             layersNeedPlacement.emplace_back(renderLayer);
         }
@@ -393,6 +386,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         imageManager->reduceMemoryUseIfCacheSizeExceedsLimit();
     }
 
+    // Create render items and render tree.
     std::vector<std::unique_ptr<RenderItem>> sourceRenderItems;
     for (const auto& entry : renderSources) {
         if (entry.second->isEnabled()) {
@@ -400,6 +394,12 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         }
     }
 
+    std::vector<LayerRenderItem> layerRenderItems;
+    layerRenderItems.reserve(orderedRenderLayers.size());
+    for (auto& entry : orderedRenderLayers) {
+        layerRenderItems.emplace_back(entry.layer.get().createRenderItem());
+    }
+
     return std::make_unique<RenderTreeImpl>(
         std::move(renderTreeParameters),
         std::move(layerRenderItems),