[core] Introduce ImageSourceRenderData and RenderSource::getImageRenderData()

Image source render data is owned by render source, which is simpler than the
previous approach and aligned with the render tiles ownership model.

5 files changed, 45 insertions, 36 deletions

diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 9811899d83..e22e14275c 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
+#include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/programs/raster_program.hpp>
 #include <mbgl/tile/tile.hpp>
@@ -74,13 +75,7 @@ static std::array<float, 3> spinWeights(float spin) {
 
 void RenderRasterLayer::prepare(const LayerPrepareParameters& params) {
     RenderLayer::prepare(params);
-    auto* imageSource = params.source->as<RenderImageSource>();
-    if (imageSource && imageSource->isLoaded()) {
-        assert(imageSource->isEnabled());
-        assert(imageSource->sharedData.bucket);
-        assert(imageSource->sharedData.matrices);
-        imageData = imageSource->sharedData;
-    }
+    imageData = params.source->getImageRenderData();
 }
 
 void RenderRasterLayer::render(PaintParameters& parameters) {
@@ -147,7 +142,7 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
         assert(bucket.texture);
 
         size_t i = 0;
-        for (const auto& matrix_ : *imageData->matrices) {
+        for (const auto& matrix_ : imageData->matrices) {
             draw(matrix_,
                 *bucket.vertexBuffer,
                 *bucket.indexBuffer,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 9ef7c9837f..94bbd36a0d 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -1,12 +1,13 @@
 #pragma once
 
 #include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 #include <mbgl/style/layers/raster_layer_properties.hpp>
 
 namespace mbgl {
 
+class ImageSourceRenderData;
+
 class RenderRasterLayer final : public RenderLayer {
 public:
     explicit RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
@@ -22,7 +23,7 @@ private:
 
     // Paint properties
     style::RasterPaintProperties::Unevaluated unevaluated;
-    optional<ImageLayerRenderData> imageData;
+    const ImageSourceRenderData* imageData = nullptr;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index 57c5b6fb7f..2603aa1273 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -29,6 +29,7 @@ class TileParameters;
 class CollisionIndex;
 class TransformParameters;
 class ImageManager;
+class ImageSourceRenderData;
 
 namespace gfx {
 class UploadPass;
@@ -77,9 +78,8 @@ public:
     virtual bool hasFadingTiles() const = 0;
     // Returns a list of RenderTiles, sorted by tile id.
     virtual std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() = 0;
-    virtual const Tile* getRenderedTile(const UnwrappedTileID&) const {
-        return nullptr;
-    }
+    virtual const ImageSourceRenderData* getImageRenderData() const { return nullptr; }
+    virtual const Tile* getRenderedTile(const UnwrappedTileID&) const { return nullptr; }
 
     virtual std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index db5ba75ffc..04edced011 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -28,12 +28,12 @@ const style::ImageSource::Impl& RenderImageSource::impl() const {
 }
 
 bool RenderImageSource::isLoaded() const {
-    return !!sharedData.bucket;
+    return !!bucket;
 }
 
 void RenderImageSource::upload(gfx::UploadPass& uploadPass) {
-    if (sharedData.bucket->needsUpload()) {
-        sharedData.bucket->upload(uploadPass);
+    if (bucket->needsUpload()) {
+        bucket->upload(uploadPass);
     }
 }
 
@@ -42,27 +42,30 @@ void RenderImageSource::prepare(const SourcePrepareParameters& parameters) {
         return;
     }
 
-    sharedData.matrices = std::make_shared<std::vector<mat4>>(tileIds.size(), mat4());
+    std::vector<mat4> matrices{tileIds.size(), mat4()};
     const auto& transformParams = parameters.transform;
     for (size_t i = 0u; i < tileIds.size(); ++i) {
-        mat4& matrix = (*sharedData.matrices)[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)) {
         return;
     }
+    assert(renderData);
 
     static const style::Properties<>::PossiblyEvaluated properties {};
     static const DebugProgram::Binders paintAttributeData(properties, 0);
 
     auto& programInstance = parameters.programs.debug;
 
-    for (auto matrix : *sharedData.matrices) {
+    for (auto matrix : renderData->matrices) {
         programInstance.draw(
             parameters.context,
             *parameters.renderPass,
@@ -193,29 +196,29 @@ void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
         auto gc = TileCoordinate::toGeometryCoordinate(tileIds[0], tileCoords);
         geomCoords.push_back(gc);
     }
-    if (!sharedData.bucket) {
-        sharedData.bucket = std::make_unique<RasterBucket>(image);
+    if (!bucket) {
+        bucket = std::make_shared<RasterBucket>(image);
     } else {
-        sharedData.bucket->clear();
-        if (image != sharedData.bucket->image) {
-            sharedData.bucket->setImage(image);
+        bucket->clear();
+        if (image != bucket->image) {
+            bucket->setImage(image);
         }
     }
 
     // Set Bucket Vertices, Indices, and segments
-    sharedData.bucket->vertices.emplace_back(
+    bucket->vertices.emplace_back(
         RasterProgram::layoutVertex({ geomCoords[0].x, geomCoords[0].y }, { 0, 0 }));
-    sharedData.bucket->vertices.emplace_back(
+    bucket->vertices.emplace_back(
         RasterProgram::layoutVertex({ geomCoords[1].x, geomCoords[1].y }, { util::EXTENT, 0 }));
-    sharedData.bucket->vertices.emplace_back(
+    bucket->vertices.emplace_back(
         RasterProgram::layoutVertex({ geomCoords[3].x, geomCoords[3].y }, { 0, util::EXTENT }));
-    sharedData.bucket->vertices.emplace_back(
+    bucket->vertices.emplace_back(
         RasterProgram::layoutVertex({ geomCoords[2].x, geomCoords[2].y }, { util::EXTENT, util::EXTENT }));
 
-    sharedData.bucket->indices.emplace_back(0, 1, 2);
-    sharedData.bucket->indices.emplace_back(1, 2, 3);
+    bucket->indices.emplace_back(0, 1, 2);
+    bucket->indices.emplace_back(1, 2, 3);
 
-    sharedData.bucket->segments.emplace_back(0, 0, 4, 6);
+    bucket->segments.emplace_back(0, 0, 4, 6);
 }
 
 void RenderImageSource::dumpDebugLogs() const {
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index f1d3a86db1..ac9bdbecb7 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -2,21 +2,26 @@
 
 #include <mbgl/renderer/render_source.hpp>
 #include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/render_tree.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
 
 namespace mbgl {
 
 class RasterBucket;
 
-class ImageLayerRenderData {
+class ImageSourceRenderData {
 public:
+    ImageSourceRenderData(std::shared_ptr<RasterBucket> bucket_,
+                          std::vector<mat4> matrices_)
+        : bucket(std::move(bucket_)),
+          matrices(std::move(matrices_)) {}
     std::shared_ptr<RasterBucket> bucket;
-    std::shared_ptr<std::vector<mat4>> matrices;
+    std::vector<mat4> matrices;
 };
 
-class RenderImageSource : public RenderSource {
+class RenderImageSource final : public RenderSource {
 public:
-    RenderImageSource(Immutable<style::ImageSource::Impl>);
+    explicit RenderImageSource(Immutable<style::ImageSource::Impl>);
     ~RenderImageSource() override;
 
     bool isLoaded() const final;
@@ -37,6 +42,10 @@ public:
         return {};
     }
 
+    const ImageSourceRenderData* getImageRenderData() const override { 
+        return renderData.get();
+    }
+
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
@@ -54,7 +63,8 @@ private:
     friend class RenderRasterLayer;
     const style::ImageSource::Impl& impl() const;
 
-    ImageLayerRenderData sharedData;
+    std::shared_ptr<RasterBucket> bucket;
+    std::unique_ptr<ImageSourceRenderData> renderData;
     std::vector<UnwrappedTileID> tileIds;
 };