[core] RenderSource creates render items

4 files changed, 104 insertions, 67 deletions

diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 04edced011..7e793c6a4a 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -17,55 +17,25 @@ namespace mbgl {
 
 using namespace style;
 
-RenderImageSource::RenderImageSource(Immutable<style::ImageSource::Impl> impl_)
-    : RenderSource(impl_) {
-}
-
-RenderImageSource::~RenderImageSource() = default;
-
-const style::ImageSource::Impl& RenderImageSource::impl() const {
-    return static_cast<const style::ImageSource::Impl&>(*baseImpl);
-}
+ImageSourceRenderData::~ImageSourceRenderData() = default;
 
-bool RenderImageSource::isLoaded() const {
-    return !!bucket;
-}
-
-void RenderImageSource::upload(gfx::UploadPass& uploadPass) {
-    if (bucket->needsUpload()) {
+void ImageSourceRenderData::upload(gfx::UploadPass& uploadPass) const {
+    if (bucket && bucket->needsUpload()) {
         bucket->upload(uploadPass);
     }
 }
 
-void RenderImageSource::prepare(const SourcePrepareParameters& parameters) {
-    if (!isLoaded()) {
-        return;
-    }
-
-    std::vector<mat4> matrices{tileIds.size(), mat4()};
-    const auto& transformParams = parameters.transform;
-    for (size_t i = 0u; i < tileIds.size(); ++i) {
-        mat4& matrix = matrices[i];
-        matrix::identity(matrix);
-        transformParams.state.matrixFor(matrix, tileIds[i]);
-        matrix::multiply(matrix, transformParams.alignedProjMatrix, matrix);
-    }
-
-    renderData = std::make_unique<ImageSourceRenderData>(bucket, std::move(matrices));
-}
-
-void RenderImageSource::finishRender(PaintParameters& parameters) {
-    if (!isLoaded() || !(parameters.debugOptions & MapDebugOptions::TileBorders)) {
+void ImageSourceRenderData::render(PaintParameters& parameters) const {
+    if (!bucket || !(parameters.debugOptions & MapDebugOptions::TileBorders)) {
         return;
     }
-    assert(renderData);
 
     static const style::Properties<>::PossiblyEvaluated properties {};
     static const DebugProgram::Binders paintAttributeData(properties, 0);
 
     auto& programInstance = parameters.programs.debug;
 
-    for (auto matrix : renderData->matrices) {
+    for (auto matrix : matrices) {
         programInstance.draw(
             parameters.context,
             *parameters.renderPass,
@@ -96,6 +66,43 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
     }
 }
 
+RenderImageSource::RenderImageSource(Immutable<style::ImageSource::Impl> impl_)
+    : RenderSource(std::move(impl_)) {
+}
+
+RenderImageSource::~RenderImageSource() = default;
+
+const style::ImageSource::Impl& RenderImageSource::impl() const {
+    return static_cast<const style::ImageSource::Impl&>(*baseImpl);
+}
+
+bool RenderImageSource::isLoaded() const {
+    return !!bucket;
+}
+
+std::unique_ptr<RenderItem> RenderImageSource::createRenderItem() {
+    assert(renderData);
+    return std::move(renderData);
+}
+
+void RenderImageSource::prepare(const SourcePrepareParameters& parameters) {
+    assert(!renderData);
+    if (!isLoaded()) {
+        renderData = std::make_unique<ImageSourceRenderData>(bucket, std::vector<mat4>{}, baseImpl->id);
+        return;
+    }
+
+    std::vector<mat4> matrices{tileIds.size(), mat4()};
+    const auto& transformParams = parameters.transform;
+    for (size_t i = 0u; i < tileIds.size(); ++i) {
+        mat4& matrix = matrices[i];
+        matrix::identity(matrix);
+        transformParams.state.matrixFor(matrix, tileIds[i]);
+        matrix::multiply(matrix, transformParams.alignedProjMatrix, matrix);
+    }
+    renderData = std::make_unique<ImageSourceRenderData>(bucket, std::move(matrices), baseImpl->id);
+}
+
 std::unordered_map<std::string, std::vector<Feature>>
 RenderImageSource::queryRenderedFeatures(const ScreenLineString&,
                                          const TransformState&,
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index 804daeef87..d21f4fae10 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -9,14 +9,25 @@ namespace mbgl {
 
 class RasterBucket;
 
-class ImageSourceRenderData {
+class ImageSourceRenderData final : public RenderItem {
 public:
     ImageSourceRenderData(std::shared_ptr<RasterBucket> bucket_,
-                          std::vector<mat4> matrices_)
+                          std::vector<mat4> matrices_,
+                          std::string name_)
         : bucket(std::move(bucket_)),
-          matrices(std::move(matrices_)) {}
-    std::shared_ptr<RasterBucket> bucket;
-    std::vector<mat4> matrices;
+          matrices(std::move(matrices_)),
+          name(std::move(name_)) {}
+    ~ImageSourceRenderData() override;
+    const std::shared_ptr<RasterBucket> bucket;
+    const std::vector<mat4> matrices;
+
+private:
+    void upload(gfx::UploadPass&) const override;
+    void render(PaintParameters&) const override;
+    bool hasRenderPass(RenderPass) const override { return false; }
+    const std::string& getName() const override { return name; }
+
+    std::string name;
 };
 
 class RenderImageSource final : public RenderSource {
@@ -26,9 +37,8 @@ public:
 
     bool isLoaded() const final;
 
-    void upload(gfx::UploadPass&) final;
+    std::unique_ptr<RenderItem> createRenderItem() override;
     void prepare(const SourcePrepareParameters&) final;
-    void finishRender(PaintParameters&) final;
     void updateFadingTiles() final {}
     bool hasFadingTiles() const final { return false; }
 
@@ -38,9 +48,7 @@ public:
                 bool needsRelayout,
                 const TileParameters&) final;
 
-    std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final {
-        return {};
-    }
+    RenderTiles getRenderTiles() override { return {}; }
 
     const ImageSourceRenderData* getImageRenderData() const override { 
         return renderData.get();
diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp
index 3af3b92e77..99bdfde485 100644
--- a/src/mbgl/renderer/sources/render_tile_source.cpp
+++ b/src/mbgl/renderer/sources/render_tile_source.cpp
@@ -2,6 +2,7 @@
 
 #include <mbgl/renderer/buckets/debug_bucket.hpp>
 #include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/render_tree.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/tile_render_data.hpp>
 #include <mbgl/tile/vector_tile.hpp>
@@ -10,8 +11,37 @@ namespace mbgl {
 
 using namespace style;
 
+class TileSourceRenderItem : public RenderItem {
+public:
+    TileSourceRenderItem(Immutable<std::vector<RenderTile>> renderTiles_, std::string name_)
+        : renderTiles(std::move(renderTiles_))
+        , name(std::move(name_)) {}
+
+private:
+    void upload(gfx::UploadPass&) const override;
+    void render(PaintParameters&) const override;
+    bool hasRenderPass(RenderPass) const override { return false; }
+    const std::string& getName() const override { return name; }
+
+    Immutable<std::vector<RenderTile>> renderTiles;
+    std::string name;
+};
+
+void TileSourceRenderItem::upload(gfx::UploadPass& parameters) const {
+    for (auto& tile : *renderTiles) {
+        tile.upload(parameters);
+    }
+}
+
+void TileSourceRenderItem::render(PaintParameters& parameters) const {
+    for (auto& tile : *renderTiles) {
+        tile.finishRender(parameters);
+    }
+}
+
 RenderTileSource::RenderTileSource(Immutable<style::Source::Impl> impl_)
-    : RenderSource(std::move(impl_)) {
+    : RenderSource(std::move(impl_))
+    , renderTiles(makeMutable<std::vector<RenderTile>>()) {
     tilePyramid.setObserver(this);
 }
 
@@ -21,25 +51,18 @@ bool RenderTileSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
 
-void RenderTileSource::upload(gfx::UploadPass& parameters) {
-    for (auto& tile : renderTiles) {
-        tile.upload(parameters);
-    }
+std::unique_ptr<RenderItem> RenderTileSource::createRenderItem() {
+    return std::make_unique<TileSourceRenderItem>(renderTiles, baseImpl->id);
 }
 
 void RenderTileSource::prepare(const SourcePrepareParameters& parameters) {
-    renderTiles.clear();
-    renderTiles.reserve(tilePyramid.getRenderedTiles().size());
+    auto tiles = makeMutable<std::vector<RenderTile>>();
+    tiles->reserve(tilePyramid.getRenderedTiles().size());
     for (auto& entry : tilePyramid.getRenderedTiles()) {
-        renderTiles.emplace_back(entry.first, entry.second);
-        renderTiles.back().prepare(parameters);
-    }
-}
-
-void RenderTileSource::finishRender(PaintParameters& parameters) {
-    for (auto& tile : renderTiles) {
-        tile.finishRender(parameters);
+        tiles->emplace_back(entry.first, entry.second);
+        tiles->back().prepare(parameters);
     }
+    renderTiles = std::move(tiles);
 }
 
 void RenderTileSource::updateFadingTiles() {
@@ -50,8 +73,8 @@ bool RenderTileSource::hasFadingTiles() const {
     return tilePyramid.hasFadingTiles();
 }
 
-std::vector<std::reference_wrapper<RenderTile>> RenderTileSource::getRenderTiles() {
-    return { renderTiles.begin(), renderTiles.end() };
+RenderTiles RenderTileSource::getRenderTiles() {
+    return { renderTiles->begin(), renderTiles->end() };
 }
 
 const Tile* RenderTileSource::getRenderedTile(const UnwrappedTileID& tileID) const {
diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp
index 91b453968d..e3148b45b9 100644
--- a/src/mbgl/renderer/sources/render_tile_source.hpp
+++ b/src/mbgl/renderer/sources/render_tile_source.hpp
@@ -16,13 +16,12 @@ public:
 
     bool isLoaded() const override;
 
-    void upload(gfx::UploadPass&) override;
+    std::unique_ptr<RenderItem> createRenderItem() override;
     void prepare(const SourcePrepareParameters&) override;
-    void finishRender(PaintParameters&) override;
     void updateFadingTiles() override;
     bool hasFadingTiles() const override;
 
-    std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() override;
+    RenderTiles getRenderTiles() override;
     const Tile* getRenderedTile(const UnwrappedTileID&) const override;
 
     std::unordered_map<std::string, std::vector<Feature>>
@@ -40,7 +39,7 @@ public:
 
 protected:
     TilePyramid tilePyramid;
-    std::vector<RenderTile> renderTiles;
+    Immutable<std::vector<RenderTile>> renderTiles;
 };
 
 } // namespace mbgl