Fill in more of ImageSource and RenderImageSource

Remove tile depdendence from raster painter
Use getID() instead of direct access thru baseImpl

13 files changed, 97 insertions, 43 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index fbc300f5e8..8f4949d45c 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -72,8 +72,6 @@ set(MBGL_CORE_FILES
     src/mbgl/gl/object.hpp
     src/mbgl/gl/primitives.hpp
     src/mbgl/gl/program.hpp
-    src/mbgl/gl/program_binary.cpp
-    src/mbgl/gl/program_binary.hpp
     src/mbgl/gl/program_binary_extension.hpp
     src/mbgl/gl/renderbuffer.hpp
     src/mbgl/gl/segment.cpp
@@ -244,6 +242,8 @@ set(MBGL_CORE_FILES
     # renderer/sources
     src/mbgl/renderer/sources/render_geojson_source.cpp
     src/mbgl/renderer/sources/render_geojson_source.hpp
+    src/mbgl/renderer/sources/render_image_source.cpp
+    src/mbgl/renderer/sources/render_image_source.hpp
     src/mbgl/renderer/sources/render_raster_source.cpp
     src/mbgl/renderer/sources/render_raster_source.hpp
     src/mbgl/renderer/sources/render_vector_source.cpp
diff --git a/include/mbgl/style/sources/image_source.hpp b/include/mbgl/style/sources/image_source.hpp
index 92ba8b3373..edc19a7e51 100644
--- a/include/mbgl/style/sources/image_source.hpp
+++ b/include/mbgl/style/sources/image_source.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mbgl/style/source.hpp>
+#include <mbgl/util/image.hpp>
 
 namespace mbgl {
 class LatLng;
@@ -13,7 +14,7 @@ public:
     
     const std::string& getURL() const;
     void setURL(const std::string& url) ;
-
+    void setImage(mbgl::UnassociatedImage);
     void setCoordinates(const std::vector<LatLng>);
     
     // Private implementation
diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp
index 4a25959868..01e4180008 100644
--- a/src/mbgl/renderer/buckets/raster_bucket.cpp
+++ b/src/mbgl/renderer/buckets/raster_bucket.cpp
@@ -3,7 +3,7 @@
 #include <mbgl/programs/raster_program.hpp>
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/gl/context.hpp>
-
+#include <mbgl/renderer/render_tile.hpp>
 namespace mbgl {
 
 using namespace style;
@@ -20,7 +20,7 @@ void RasterBucket::render(Painter& painter,
                           PaintParameters& parameters,
                           const RenderLayer& layer,
                           const RenderTile& tile) {
-    painter.renderRaster(parameters, *this, *layer.as<RenderRasterLayer>(), tile);
+    painter.renderRaster(parameters, *this, *layer.as<RenderRasterLayer>(), tile.matrix);
 }
 
 bool RasterBucket::hasData() const {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 7649f86ca6..33fcdeb3ca 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -179,12 +179,7 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view, Sp
         annotationSpriteAtlas.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);
-                }
-            }
+            uploadItem(item);
         }
     }
 
@@ -336,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());
@@ -364,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);
         }
     }
 
@@ -378,6 +362,25 @@ void Painter::renderPass(PaintParameters& parameters,
     }
 }
 
+void Painter::renderItem(PaintParameters& parameters, const RenderItem& item) {
+    const RenderLayer& layer = item.layer;
+    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);
+        bucket->render(*this, parameters, layer, tile);
+    }
+}
+
+void Painter::uploadItem(const RenderItem& item) {
+    for (const auto& tileRef : item.tiles) {
+        const auto& bucket = tileRef.get().tile.getBucket(item.layer);
+        if (bucket && bucket->needsUpload()) {
+            bucket->upload(context);
+        }
+    }
+}
+
 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 47b469d971..83f6316737 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -91,9 +91,11 @@ public:
     void renderLine(PaintParameters&, LineBucket&, const RenderLineLayer&, const RenderTile&);
     void renderCircle(PaintParameters&, CircleBucket&, const RenderCircleLayer&, const RenderTile&);
     void renderSymbol(PaintParameters&, SymbolBucket&, const RenderSymbolLayer&, const RenderTile&);
-    void renderRaster(PaintParameters&, RasterBucket&, const RenderRasterLayer&, const RenderTile&);
+    void renderRaster(PaintParameters&, RasterBucket&, const RenderRasterLayer&, const mat4&);
     void renderBackground(PaintParameters&, const RenderBackgroundLayer&);
 
+    void renderItem(PaintParameters&, const RenderItem&);
+    void uploadItem(const RenderItem& );
 #ifndef NDEBUG
     // Renders tile clip boundaries, using stencil buffer to calculate fill color.
     void renderClipMasks(PaintParameters&);
@@ -104,8 +106,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/painters/painter_raster.cpp b/src/mbgl/renderer/painters/painter_raster.cpp
index 1f0d72be40..0f2da7981c 100644
--- a/src/mbgl/renderer/painters/painter_raster.cpp
+++ b/src/mbgl/renderer/painters/painter_raster.cpp
@@ -42,7 +42,7 @@ static std::array<float, 3> spinWeights(float spin) {
 void Painter::renderRaster(PaintParameters& parameters,
                            RasterBucket& bucket,
                            const RenderRasterLayer& layer,
-                           const RenderTile& tile) {
+                           const mat4& matrix) {
     if (pass != RenderPass::Translucent)
         return;
     if (!bucket.hasData())
@@ -62,7 +62,7 @@ void Painter::renderRaster(PaintParameters& parameters,
         gl::StencilMode::disabled(),
         colorModeForRenderPass(),
         RasterProgram::UniformValues {
-            uniforms::u_matrix::Value{ tile.matrix },
+            uniforms::u_matrix::Value{ matrix },
             uniforms::u_image0::Value{ 0 },
             uniforms::u_image1::Value{ 1 },
             uniforms::u_opacity::Value{ properties.get<RasterOpacity>() },
diff --git a/src/mbgl/renderer/render_item.hpp b/src/mbgl/renderer/render_item.hpp
index 787211c30a..4e557dab26 100644
--- a/src/mbgl/renderer/render_item.hpp
+++ b/src/mbgl/renderer/render_item.hpp
@@ -18,11 +18,13 @@ namespace style {
 class RenderItem {
 public:
     RenderItem(const RenderLayer& layer_,
+               RenderSource * renderSource_,
                std::vector<std::reference_wrapper<RenderTile>> tiles_ = {})
-        : layer(layer_), tiles(std::move(tiles_)) {
+        : layer(layer_), source(renderSource_), tiles(std::move(tiles_)) {
     }
 
     const RenderLayer& layer;
+    const RenderSource* source;
     std::vector<std::reference_wrapper<RenderTile>> tiles;
 };
 
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 555c64f24e..9ad0d9d7bc 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -2,6 +2,9 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/algorithm/generate_clip_ids.hpp>
 #include <mbgl/algorithm/generate_clip_ids_impl.hpp>
+#include <mbgl/renderer/raster_bucket.hpp>
+#include <mbgl/map/transform_state.hpp>
+#include <mbgl/renderer/tile_parameters.hpp>
 
 namespace mbgl {
 
@@ -9,16 +12,20 @@ using namespace style;
 
 RenderImageSource::RenderImageSource(const style::ImageSource::Impl& impl_)
 : RenderSource(impl_),
-impl(impl_) {
+ impl(impl_),
+ isImageLoaded(false) {
+    bucket = nullptr;
 }
 
 bool RenderImageSource::isLoaded() const {
-    return false;
+    return isImageLoaded;
 }
 
 void RenderImageSource::startRender(algorithm::ClipIDGenerator& ,
-                                    const mat4& , const mat4& , const TransformState& ) {
-    impl.getData();
+                                    const mat4& ,
+                                    const mat4& ,
+                                    const TransformState& ) {
+
 }
 
 void RenderImageSource::finishRender(Painter& ) {
@@ -39,7 +46,11 @@ void RenderImageSource::removeTiles() {
 
 }
 
-void RenderImageSource::updateTiles(const TileParameters&) {
+void RenderImageSource::updateTiles(const TileParameters& ) {
+    if(!isImageLoaded && impl.loaded) {
+        bucket = new RasterBucket(std::move(*impl.getData()));
+        isImageLoaded = true;
+    }
 }
 
 void RenderImageSource::reloadTiles() {
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index bc4003a22e..ee6928171f 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/style/sources/image_source_impl.hpp>
 
 namespace mbgl {
+class RasterBucket;
 
 class RenderImageSource : public RenderSource {
 public:
@@ -36,9 +37,12 @@ public:
     void onLowMemory() final;
     void dumpDebugLogs() const final;
 
+    RasterBucket* bucket;
+
 private:
     const style::ImageSource::Impl& impl;
     std::map<UnwrappedTileID, RenderTile> tiles;
+    bool isImageLoaded;
 };
     
 } // namespace mbgl
diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp
index 51e4f57e82..3034037c89 100644
--- a/src/mbgl/style/sources/image_source.cpp
+++ b/src/mbgl/style/sources/image_source.cpp
@@ -20,6 +20,10 @@ void ImageSource::setURL(const std::string& url) {
     impl->setURL(url);
 }
 
+    void ImageSource::setImage(mbgl::UnassociatedImage image) {
+    impl->setImage(std::move(image));
+}
+
 const std::string& ImageSource::getURL() const {
      return impl->getURL();
 }
diff --git a/src/mbgl/style/sources/image_source_impl.cpp b/src/mbgl/style/sources/image_source_impl.cpp
index b889895b8e..76739067c1 100644
--- a/src/mbgl/style/sources/image_source_impl.cpp
+++ b/src/mbgl/style/sources/image_source_impl.cpp
@@ -23,6 +23,7 @@ ImageSource::Impl::~Impl() = default;
 
 void ImageSource::Impl::setURL(std::string url_) {
     url = std::move(url_);
+    observer->onSourceChanged(base);
 }
 
 const std::string& ImageSource::Impl::getURL() const {
@@ -31,6 +32,17 @@ const std::string& ImageSource::Impl::getURL() const {
 
 void ImageSource::Impl::setCoordinates(const std::vector<LatLng> coords_) {
     coords = std::move(coords_);
+    observer->onSourceChanged(base);
+
+}
+
+std::vector<LatLng> ImageSource::Impl::getCoordinates() const {
+    return coords;
+}
+
+void ImageSource::Impl::setImage(mbgl::UnassociatedImage image_) {
+    image = std::make_unique<mbgl::UnassociatedImage>(std::move(image_));
+    observer->onSourceChanged(base);
 }
 
 std::unique_ptr<RenderSource> ImageSource::Impl::createRenderSource() const {
@@ -58,15 +70,29 @@ void ImageSource::Impl::loadDescription(FileSource& fileSource) {
                 observer->onSourceError(base, std::current_exception());
             }
 
+            // Check whether previous information specifies different coordinates ?
+            bool attributionChanged = false;
+            if (false) {
+                // TODO: AHM: If URL/Coordinates changed, invalidate existing bucket(s)
+                // TODO: AHM: If Min/Max zoom changed: ?
+                // Attribution changed: We need to notify the embedding application that this
+                // changed.
+                attributionChanged = true;
+            }
+
             loaded = true;
 
             observer->onSourceLoaded(base);
+            if (attributionChanged) {
+                observer->onSourceChanged(base);
+            }
         }
     });
 }
 
-mbgl::UnassociatedImage* ImageSource::Impl::getData() const {
-    return image.get();
+std::unique_ptr<mbgl::UnassociatedImage> ImageSource::Impl::getData() const {
+    UnassociatedImage * img = image.get();
+    return std::make_unique<UnassociatedImage>(std::move(*img));
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/image_source_impl.hpp b/src/mbgl/style/sources/image_source_impl.hpp
index 0f1be625b9..d6b1488924 100644
--- a/src/mbgl/style/sources/image_source_impl.hpp
+++ b/src/mbgl/style/sources/image_source_impl.hpp
@@ -17,11 +17,14 @@ public:
 
     ~Impl() final;
 
+    void setImage(mbgl::UnassociatedImage);
+
     void setURL(std::string);
     const std::string& getURL() const;
     void setCoordinates(const std::vector<LatLng> coords);
+    std::vector<LatLng> getCoordinates() const;
 
-    mbgl::UnassociatedImage* getData() const;
+    std::unique_ptr<mbgl::UnassociatedImage> getData() const;
 
     void loadDescription(FileSource&) final;
 
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 84ee841c06..223a967a17 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -544,7 +544,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;
@@ -553,19 +553,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;
         }
 
@@ -625,7 +625,7 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
             }
         }
 
-        result.order.emplace_back(*layer, std::move(sortedTilesForInsertion));
+        result.order.emplace_back(*layer, source, std::move(sortedTilesForInsertion));
     }
 
     return result;