[core] Merge RenderLayer::uploadBuckets into RenderSource::startRender

src/mbgl/renderer/layers/render_raster_layer.cpp

@@ -36,16 +36,6 @@ bool RenderRasterLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderRasterLayer::uploadBuckets(gl::Context& context, RenderSource* source) {
-    RenderLayer::uploadBuckets(context, source);
-    if (renderTiles.empty()) {
-        RenderImageSource* imageSource = source->as<RenderImageSource>();
-        if (imageSource) {
-            imageSource->upload(context);
-        }
-    }
-}
-
 void RenderRasterLayer::render(Painter& painter, PaintParameters& parameters, RenderSource* source) {
     RenderLayer::render(painter, parameters, source);
     if (renderTiles.empty()) {

src/mbgl/renderer/layers/render_raster_layer.hpp

@@ -15,8 +15,7 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&, RenderSource*) override;
-    void render(Painter& , PaintParameters& , RenderSource*) override;
+    void render(Painter&, PaintParameters&, RenderSource*) override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
 

src/mbgl/renderer/painter.cpp

@@ -174,10 +174,6 @@ void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
         lineAtlas->upload(context, 0);
         glyphAtlas->upload(context, 0);
         frameHistory.upload(context, 0);
-
-        for (const auto& item : order) {
-            item.layer.uploadBuckets(context, item.source);
-        }
     }
 
     // - CLEAR -------------------------------------------------------------------------------------

src/mbgl/renderer/render_layer.cpp

@@ -68,15 +68,6 @@ void RenderLayer::setRenderTiles(std::vector<std::reference_wrapper<RenderTile>>
     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();

src/mbgl/renderer/render_layer.hpp

@@ -66,8 +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);
+    virtual void render(Painter&, PaintParameters&, RenderSource*);
+
     // Check wether the given geometry intersects
     // with the feature
     virtual bool queryIntersectsFeature(

src/mbgl/renderer/render_tile.cpp

@@ -1,6 +1,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/map/transform_state.hpp>
+#include <mbgl/tile/tile.hpp>
 
 namespace mbgl {
 
@@ -46,6 +47,8 @@ mat4 RenderTile::translatedClipMatrix(const std::array<float, 2>& translation,
 }
 
 void RenderTile::startRender(Painter& painter) {
+    tile.upload(painter.context);
+
     // Calculate two matrices for this tile: matrix is the standard tile matrix; nearClippedMatrix
     // clips the near plane to 100 to save depth buffer precision
     painter.state.matrixFor(matrix, id);

src/mbgl/renderer/sources/render_image_source.cpp

@@ -27,10 +27,10 @@ bool RenderImageSource::isLoaded() const {
 }
 
 void RenderImageSource::startRender(Painter& painter) {
-
     if (!isLoaded()) {
         return;
     }
+
     matrices.clear();
 
     for (size_t i = 0; i < tileIds.size(); i++) {
@@ -40,6 +40,10 @@ void RenderImageSource::startRender(Painter& painter) {
         matrix::multiply(matrix, painter.projMatrix, matrix);
         matrices.push_back(matrix);
     }
+
+    if (bucket->needsUpload() && shouldRender) {
+        bucket->upload(painter.context);
+    }
 }
 
 void RenderImageSource::finishRender(Painter& painter) {
@@ -63,12 +67,6 @@ std::vector<Feature> RenderImageSource::querySourceFeatures(const SourceQueryOpt
     return {};
 }
 
-void RenderImageSource::upload(gl::Context& context) {
-    if (isLoaded() && bucket->needsUpload() && shouldRender) {
-        bucket->upload(context);
-    }
-}
-
 void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
                                const std::vector<Immutable<Layer::Impl>>&,
                                const bool needsRendering,

src/mbgl/renderer/sources/render_image_source.hpp

@@ -19,7 +19,6 @@ public:
     ~RenderImageSource() override;
 
     bool isLoaded() const final;
-    void upload(gl::Context&);
 
     void startRender(Painter&) final;
     void render(Painter&, PaintParameters&, const RenderLayer&);

src/mbgl/tile/geometry_tile.cpp

@@ -161,6 +161,22 @@ void GeometryTile::getIcons(IconDependencies iconDependencies) {
     spriteAtlas.getIcons(*this, std::move(iconDependencies));
 }
 
+void GeometryTile::upload(gl::Context& context) {
+    auto upload = [&] (Bucket& bucket) {
+        if (bucket.needsUpload()) {
+            bucket.upload(context);
+        }
+    };
+
+    for (auto& entry : nonSymbolBuckets) {
+        upload(*entry.second);
+    }
+
+    for (auto& entry : symbolBuckets) {
+        upload(*entry.second);
+    }
+}
+
 Bucket* GeometryTile::getBucket(const Layer::Impl& layer) const {
     const auto& buckets = layer.type == LayerType::Symbol ? symbolBuckets : nonSymbolBuckets;
     const auto it = buckets.find(layer.id);

src/mbgl/tile/geometry_tile.hpp

@@ -44,6 +44,7 @@ public:
     void getGlyphs(GlyphDependencies);
     void getIcons(IconDependencies);
 
+    void upload(gl::Context&) override;
     Bucket* getBucket(const style::Layer::Impl&) const override;
 
     void queryRenderedFeatures(

src/mbgl/tile/raster_tile.cpp

@@ -55,6 +55,12 @@ void RasterTile::onError(std::exception_ptr err) {
     observer->onTileError(*this, err);
 }
 
+void RasterTile::upload(gl::Context& context) {
+    if (bucket) {
+        bucket->upload(context);
+    }
+}
+
 Bucket* RasterTile::getBucket(const style::Layer::Impl&) const {
     return bucket.get();
 }

src/mbgl/tile/raster_tile.hpp

@@ -29,6 +29,8 @@ public:
                  optional<Timestamp> expires_);
 
     void cancel() override;
+
+    void upload(gl::Context&) override;
     Bucket* getBucket(const style::Layer::Impl&) const override;
 
     void onParsed(std::unique_ptr<Bucket> result);

src/mbgl/tile/tile.hpp

@@ -26,6 +26,10 @@ class RenderStyle;
 class RenderedQueryOptions;
 class SourceQueryOptions;
 
+namespace gl {
+class Context;
+} // namespace gl
+
 class Tile : private util::noncopyable {
 public:
     Tile(OverscaledTileID);
@@ -45,6 +49,7 @@ public:
     // Mark this tile as no longer needed and cancel any pending work.
     virtual void cancel() = 0;
 
+    virtual void upload(gl::Context&) = 0;
     virtual Bucket* getBucket(const style::Layer::Impl&) const = 0;
 
     virtual void setPlacementConfig(const PlacementConfig&) {}