Move renderer files to folders

26 files changed, 153 insertions, 115 deletions

diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp
index 01e4180008..6c5c47aa72 100644
--- a/src/mbgl/renderer/buckets/raster_bucket.cpp
+++ b/src/mbgl/renderer/buckets/raster_bucket.cpp
@@ -4,8 +4,8 @@
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/renderer/render_tile.hpp>
-namespace mbgl {
 
+namespace mbgl {
 using namespace style;
 
 RasterBucket::RasterBucket(UnassociatedImage&& image_) : image(std::move(image_)) {
@@ -13,6 +13,10 @@ RasterBucket::RasterBucket(UnassociatedImage&& image_) : image(std::move(image_)
 
 void RasterBucket::upload(gl::Context& context) {
     texture = context.createTexture(std::move(image));
+    if (vertices.vertexSize() > 0) {
+        vertexBuffer = context.createVertexBuffer(std::move(vertices));
+        indexBuffer = context.createIndexBuffer(std::move(indices));
+    }
     uploaded = true;
 }
 
@@ -20,7 +24,14 @@ void RasterBucket::render(Painter& painter,
                           PaintParameters& parameters,
                           const RenderLayer& layer,
                           const RenderTile& tile) {
-    painter.renderRaster(parameters, *this, *layer.as<RenderRasterLayer>(), tile.matrix);
+    painter.renderRaster(parameters, *this, *layer.as<RenderRasterLayer>(), tile.matrix, false);
+}
+
+void RasterBucket::render(Painter& painter,
+                          PaintParameters& parameters,
+                          const RenderLayer& layer,
+                          const mat4& matrix) {
+    painter.renderRaster(parameters, *this, *layer.as<RenderRasterLayer>(), matrix,true);
 }
 
 bool RasterBucket::hasData() const {
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 0e06ac4525..5de75a60cb 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -30,11 +30,11 @@ void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &paramet
                                                            : RenderPass::None;
 }
 
-void RenderBackgroundLayer::uploadBuckets(gl::Context&) {
+void RenderBackgroundLayer::uploadBuckets(gl::Context&, RenderSource*) {
 }
 
 
-void RenderBackgroundLayer::render(Painter& , PaintParameters& , const RenderSource*) {
+void RenderBackgroundLayer::render(Painter& , PaintParameters& , RenderSource*) {
 }
 
 
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index 1db17e7e33..bd2ec7d853 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -15,8 +15,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
 
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index bd313f4816..24abf5253e 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -42,7 +42,7 @@ bool RenderCircleLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderCircleLayer::uploadBuckets(gl::Context& context) {
+void RenderCircleLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
         const auto& bucket = tileRef.get().tile.getBucket(*this);
         if (bucket && bucket->needsUpload()) {
@@ -51,10 +51,9 @@ void RenderCircleLayer::uploadBuckets(gl::Context& context) {
     }
 }
 
-void RenderCircleLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
+void RenderCircleLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
         auto bucket = tile.tile.getBucket(*this);
         bucket->render(painter, parameters, *this, tile);
     }
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index ef5b2c9756..f58a936b5d 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -15,8 +15,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index a6e67b3974..4b2bc2c294 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -21,10 +21,10 @@ bool RenderCustomLayer::hasTransition() const {
     return false;
 }
 
-void RenderCustomLayer::uploadBuckets(gl::Context&) {
+void RenderCustomLayer::uploadBuckets(gl::Context&, RenderSource*) {
 }
 
-void RenderCustomLayer::render(Painter& , PaintParameters& , const RenderSource*) {
+void RenderCustomLayer::render(Painter& , PaintParameters& , RenderSource*) {
 }
 
 
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index 2b832a7b92..d0b8ec6236 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -14,8 +14,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const final;
 
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 16198f1ca5..25dae7a58b 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -37,7 +37,7 @@ bool RenderFillExtrusionLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderFillExtrusionLayer::uploadBuckets(gl::Context& context) {
+void RenderFillExtrusionLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
         const auto& bucket = tileRef.get().tile.getBucket(*this);
         if (bucket && bucket->needsUpload()) {
@@ -46,10 +46,9 @@ void RenderFillExtrusionLayer::uploadBuckets(gl::Context& context) {
     }
 }
 
-void RenderFillExtrusionLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
+void RenderFillExtrusionLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
         auto bucket = tile.tile.getBucket(*this);
         bucket->render(painter, parameters, *this, tile);
     }
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index 5265cdb7e8..6c1ab9bdee 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -15,8 +15,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     bool queryIntersectsFeature(
         const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 3334371431..9cb36008ce 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -52,7 +52,7 @@ bool RenderFillLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderFillLayer::uploadBuckets(gl::Context& context) {
+void RenderFillLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
         const auto& bucket = tileRef.get().tile.getBucket(*this);
         if (bucket && bucket->needsUpload()) {
@@ -61,10 +61,9 @@ void RenderFillLayer::uploadBuckets(gl::Context& context) {
     }
 }
 
-void RenderFillLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
+void RenderFillLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
         auto bucket = tile.tile.getBucket(*this);
         bucket->render(painter, parameters, *this, tile);
     }
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 4748e892be..d7e00a1f6d 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -15,8 +15,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 34a18c7584..fe09a7441e 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -44,7 +44,7 @@ bool RenderLineLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderLineLayer::uploadBuckets(gl::Context& context) {
+void RenderLineLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
         const auto& bucket = tileRef.get().tile.getBucket(*this);
         if (bucket && bucket->needsUpload()) {
@@ -53,10 +53,9 @@ void RenderLineLayer::uploadBuckets(gl::Context& context) {
     }
 }
 
-void RenderLineLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
+void RenderLineLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
         auto bucket = tile.tile.getBucket(*this);
         bucket->render(painter, parameters, *this, tile);
     }
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 9a76e3b5a1..8fa6e6a3bd 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -15,8 +15,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 0383720592..50018b38c6 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -16,8 +16,8 @@ public:
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource*) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
 
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index bcffd60994..c89de0cbdc 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -112,7 +112,7 @@ style::SymbolPropertyValues RenderSymbolLayer::textPropertyValues(const style::S
     };
 }
 
-void RenderSymbolLayer::uploadBuckets(gl::Context& context) {
+void RenderSymbolLayer::uploadBuckets(gl::Context& context, RenderSource* ) {
     for (const auto& tileRef : renderTiles) {
         const auto& bucket = tileRef.get().tile.getBucket(*this);
         if (bucket && bucket->needsUpload()) {
@@ -121,10 +121,9 @@ void RenderSymbolLayer::uploadBuckets(gl::Context& context) {
     }
 }
 
-void RenderSymbolLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
+void RenderSymbolLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
         auto bucket = tile.tile.getBucket(*this);
         bucket->render(painter, parameters, *this, tile);
     }
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index e8ff41c045..e7f3b3ddb4 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -71,8 +71,8 @@ public:
     style::IconPaintProperties::PossiblyEvaluated iconPaintProperties() const;
     style::TextPaintProperties::PossiblyEvaluated textPaintProperties() const;
 
-    void uploadBuckets(gl::Context&) override;
-    void render(Painter& , PaintParameters& , const RenderSource*) override;
+    void uploadBuckets(gl::Context&, RenderSource* ) override;
+    void render(Painter& , PaintParameters& , RenderSource*) override;
 
     style::SymbolPropertyValues iconPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const;
     style::SymbolPropertyValues textPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const;
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 18eddc3322..88157a7aae 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -13,6 +13,7 @@
 
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
 
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/renderer/layers/render_background_layer.hpp>
@@ -179,7 +180,7 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view, Sp
         annotationSpriteAtlas.upload(context, 0);
 
         for (const auto& item : order) {
-            item.layer.uploadBuckets(context);
+            item.layer.uploadBuckets(context, item.source);
         }
     }
 
@@ -364,9 +365,8 @@ void Painter::renderPass(PaintParameters& parameters,
 
 void Painter::renderItem(PaintParameters& parameters, const RenderItem& item) {
     RenderLayer& layer = item.layer;
-    const RenderSource * source = item.source;
-    MBGL_DEBUG_GROUP(context, layer.getID());// + " - " + util::toString(tile.id));
-    layer.render(*this, parameters, source);
+    MBGL_DEBUG_GROUP(context, layer.getID());
+    layer.render(*this, parameters, item.source);
 }
 
 mat4 Painter::matrixForTile(const UnwrappedTileID& tileID) {
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index e0fff37171..2b234aff76 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -91,7 +91,7 @@ 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 mat4&);
+    void renderRaster(PaintParameters&, RasterBucket&, const RenderRasterLayer&, const mat4&, bool useBucketBuffers /* = false */);
     void renderBackground(PaintParameters&, const RenderBackgroundLayer&);
 
     void renderItem(PaintParameters&, const RenderItem&);
diff --git a/src/mbgl/renderer/painters/painter_raster.cpp b/src/mbgl/renderer/painters/painter_raster.cpp
index 0f2da7981c..56e38ae8f4 100644
--- a/src/mbgl/renderer/painters/painter_raster.cpp
+++ b/src/mbgl/renderer/painters/painter_raster.cpp
@@ -42,7 +42,8 @@ static std::array<float, 3> spinWeights(float spin) {
 void Painter::renderRaster(PaintParameters& parameters,
                            RasterBucket& bucket,
                            const RenderRasterLayer& layer,
-                           const mat4& matrix) {
+                           const mat4& matrix,
+                           bool useBucketBuffers = false) {
     if (pass != RenderPass::Translucent)
         return;
     if (!bucket.hasData())
@@ -76,9 +77,9 @@ void Painter::renderRaster(PaintParameters& parameters,
             uniforms::u_scale_parent::Value{ 1.0f },
             uniforms::u_tl_parent::Value{ std::array<float, 2> {{ 0.0f, 0.0f }} },
         },
-        rasterVertexBuffer,
-        quadTriangleIndexBuffer,
-        rasterSegments,
+        useBucketBuffers ? *bucket.vertexBuffer : rasterVertexBuffer,
+        useBucketBuffers ? *bucket.indexBuffer : quadTriangleIndexBuffer,
+        useBucketBuffers ? bucket.segments : rasterSegments,
         paintAttributeData,
         properties,
         state.getZoom()
diff --git a/src/mbgl/renderer/render_item.hpp b/src/mbgl/renderer/render_item.hpp
index 082bd1b898..bc8e234cd4 100644
--- a/src/mbgl/renderer/render_item.hpp
+++ b/src/mbgl/renderer/render_item.hpp
@@ -23,7 +23,7 @@ public:
     }
 
     RenderLayer& layer;
-    const RenderSource * source;
+    RenderSource * source;
 };
 
 class RenderData {
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 085ad05c8b..c98003fd08 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/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&) = 0;
-    virtual void render(Painter& , PaintParameters& , const RenderSource* source) = 0;
+    virtual void uploadBuckets(gl::Context&, RenderSource* source) = 0;
+    virtual void render(Painter& , PaintParameters& , RenderSource* source) = 0;
     // Check wether the given geometry intersects
     // with the feature
     virtual bool queryIntersectsFeature(
@@ -90,6 +90,8 @@ protected:
     // Stores what render passes this layer is currently enabled for. This depends on the
     // evaluated StyleProperties object and is updated accordingly.
     RenderPass passes = RenderPass::None;
+
+    //Stores current set of tiles to be rendered for this layer.
     std::vector<std::reference_wrapper<RenderTile>> renderTiles;
 
 };
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 9ad0d9d7bc..8fca4e0de8 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -1,10 +1,9 @@
 #include <mbgl/renderer/sources/render_image_source.hpp>
 #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/renderer/buckets/raster_bucket.hpp>
 #include <mbgl/map/transform_state.hpp>
-#include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/util/tile_coordinate.hpp>
+#include <mbgl/gl/context.hpp>
 
 namespace mbgl {
 
@@ -13,19 +12,20 @@ using namespace style;
 RenderImageSource::RenderImageSource(const style::ImageSource::Impl& impl_)
 : RenderSource(impl_),
  impl(impl_),
- isImageLoaded(false) {
-    bucket = nullptr;
+ loaded(false) {
 }
 
 bool RenderImageSource::isLoaded() const {
-    return isImageLoaded;
+    return loaded;
 }
 
 void RenderImageSource::startRender(algorithm::ClipIDGenerator& ,
+                                    const mat4& projMatrix,
                                     const mat4& ,
-                                    const mat4& ,
-                                    const TransformState& ) {
-
+                                    const TransformState& transform) {
+    matrix::identity(matrix);
+    transform.matrixFor(matrix, {0,0,0});
+    matrix::multiply(matrix, projMatrix, matrix);
 }
 
 void RenderImageSource::finishRender(Painter& ) {
@@ -42,34 +42,48 @@ std::vector<Feature> RenderImageSource::querySourceFeatures(const SourceQueryOpt
     return {};
 }
 
-void RenderImageSource::removeTiles() {
-
+void RenderImageSource::upload(gl::Context& context) {
+    if (isLoaded() && bucket->needsUpload()) {
+        bucket->upload(context);
+    }
 }
 
 void RenderImageSource::updateTiles(const TileParameters& ) {
-    if(!isImageLoaded && impl.loaded) {
-        bucket = new RasterBucket(std::move(*impl.getData()));
-        isImageLoaded = true;
+    if(impl.loaded && !isLoaded()) {
+        //TODO: AHM: Don't make a copy here
+        UnassociatedImage img = impl.getData().clone();
+        bucket = std::make_unique<RasterBucket>(std::move(img));
+        loaded = true;
     }
-}
-
-void RenderImageSource::reloadTiles() {
-}
 
-void RenderImageSource::invalidateTiles() {
-}
-
-std::map<UnwrappedTileID, RenderTile>& RenderImageSource::getRenderTiles() {
-    return tiles;
-}
-
-void RenderImageSource::setCacheSize(size_t ) {
+    if (isLoaded()) {
+        auto coords = impl.getCoordinates();
+        GeometryCoordinates geomCoords;
+        for ( auto latLng : coords) {
+            geomCoords.push_back(TileCoordinate::toGeometryCoordinate(latLng));
+        }
+        assert(geomCoords.size() == 4);
+        bucket->vertices.emplace_back(RasterProgram::layoutVertex({ geomCoords[0].x, geomCoords[0].y }, { 0, 0 }));
+        bucket->vertices.emplace_back(RasterProgram::layoutVertex({ geomCoords[1].x, geomCoords[1].y }, { 32767, 0 }));
+        bucket->vertices.emplace_back(RasterProgram::layoutVertex({ geomCoords[2].x, geomCoords[2].y }, { 0, 32767 }));
+        bucket->vertices.emplace_back(RasterProgram::layoutVertex({ geomCoords[3].x, geomCoords[3].y }, { 32767, 32767 }));
+
+        bucket->indices.emplace_back(0, 1, 2);
+        bucket->indices.emplace_back(2, 3, 0);
+
+        bucket->segments.emplace_back(0, 0, 4, 6);
+    }
 }
 
-void RenderImageSource::onLowMemory() {
+void RenderImageSource::render(Painter& painter, PaintParameters& parameters, const RenderLayer& layer)  {
+    if(isLoaded() && !bucket->needsUpload()) {
+        bucket->render(painter, parameters, layer, matrix);
+    }
 }
 
 void RenderImageSource::dumpDebugLogs() const {
+    Log::Info(Event::General, "RenderImageSource::id: %s", baseImpl.id.c_str());
+    Log::Info(Event::General, "RenderImageSource::loaded: %s", isLoaded() ? "yes" : "no");
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index ee6928171f..f2485675db 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -2,47 +2,62 @@
 
 #include <mbgl/renderer/render_source.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
+#include <mbgl/tile/geometry_tile_data.hpp>
+#include <mbgl/util/optional.hpp>
 
 namespace mbgl {
+class RenderLayer;
+class PaintParameters;
 class RasterBucket;
 
+namespace gl {
+    class Context;
+}
+
 class RenderImageSource : public RenderSource {
 public:
     RenderImageSource(const style::ImageSource::Impl&);
     
     bool isLoaded() const final;
-    
+    void upload(gl::Context&) ;
+
     void startRender(algorithm::ClipIDGenerator&,
                      const mat4& projMatrix,
                      const mat4& clipMatrix,
                      const TransformState&) final;
+
+    void render      (Painter&, PaintParameters& , const RenderLayer& ) ;
+
     void finishRender(Painter&) final;
 
     void updateTiles(const TileParameters&);
-    void removeTiles();
-    void invalidateTiles();
-    void reloadTiles();
-    
-    std::map<UnwrappedTileID, RenderTile>& getRenderTiles();
+    void removeTiles() {}
+    void invalidateTiles() {}
+    void reloadTiles() {}
+
+    std::map<UnwrappedTileID, RenderTile>& getRenderTiles() {
+        return tiles;
+    }
 
     std::unordered_map<std::string, std::vector<Feature>>
     queryRenderedFeatures(const ScreenLineString& geometry,
                           const TransformState& transformState,
                           const RenderedQueryOptions& options) const final;
-    
+
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const final;
 
-    void setCacheSize(size_t) final;
-    void onLowMemory() final;
+    void setCacheSize(size_t) final {}
+    void onLowMemory() final {}
     void dumpDebugLogs() const final;
 
-    RasterBucket* bucket;
-
 private:
     const style::ImageSource::Impl& impl;
     std::map<UnwrappedTileID, RenderTile> tiles;
-    bool isImageLoaded;
+    bool loaded;
+
+    std::unique_ptr<RasterBucket> bucket;
+    mat4 matrix;
 };
     
 } // namespace mbgl
diff --git a/src/mbgl/style/sources/image_source_impl.cpp b/src/mbgl/style/sources/image_source_impl.cpp
index 76739067c1..ca88f947c5 100644
--- a/src/mbgl/style/sources/image_source_impl.cpp
+++ b/src/mbgl/style/sources/image_source_impl.cpp
@@ -2,7 +2,7 @@
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/style/source_observer.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
-#include <mbgl/renderer/raster_bucket.hpp>
+#include <mbgl/renderer/buckets/raster_bucket.hpp>
 #include <mbgl/util/premultiply.hpp>
 #include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/renderer/render_tile.hpp>
@@ -33,7 +33,6 @@ 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 {
@@ -41,7 +40,7 @@ std::vector<LatLng> ImageSource::Impl::getCoordinates() const {
 }
 
 void ImageSource::Impl::setImage(mbgl::UnassociatedImage image_) {
-    image = std::make_unique<mbgl::UnassociatedImage>(std::move(image_));
+    image = std::move(image_);
     observer->onSourceChanged(base);
 }
 
@@ -52,11 +51,12 @@ std::unique_ptr<RenderSource> ImageSource::Impl::createRenderSource() const {
 
 void ImageSource::Impl::loadDescription(FileSource& fileSource) {
 
-    if (req) {
+    if (req ||  loaded) {
         return;
     }
+    const Resource imageResource { Resource::Unknown, url, {}, Resource::Necessity::Required };
 
-    req = fileSource.request(Resource::source(url), [this](Response res) {
+    req = fileSource.request(imageResource, [this](Response res) {
         if (res.error) {
             observer->onSourceError(base, std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
@@ -65,34 +65,22 @@ void ImageSource::Impl::loadDescription(FileSource& fileSource) {
             observer->onSourceError(base, std::make_exception_ptr(std::runtime_error("unexpectedly empty image url")));
         } else {
             try {
-                image = std::make_unique<mbgl::UnassociatedImage>(util::unpremultiply(decodeImage(*res.data)));
+                //TODO: AHM: Figure out how to get the correct image pixels through
+                UnassociatedImage img = util::unpremultiply(decodeImage(*res.data));
+                UnassociatedImage img2 { img.size };
+                img2.fill(135);
+                image = std::move(img2);
             } catch (...) {
                 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);
-            }
         }
     });
 }
 
-std::unique_ptr<mbgl::UnassociatedImage> ImageSource::Impl::getData() const {
-    UnassociatedImage * img = image.get();
-    return std::make_unique<UnassociatedImage>(std::move(*img));
+const mbgl::UnassociatedImage& ImageSource::Impl::getData() const {
+    return image;
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/image_source_impl.hpp b/src/mbgl/style/sources/image_source_impl.hpp
index d6b1488924..bcb14f05f8 100644
--- a/src/mbgl/style/sources/image_source_impl.hpp
+++ b/src/mbgl/style/sources/image_source_impl.hpp
@@ -24,7 +24,7 @@ public:
     void setCoordinates(const std::vector<LatLng> coords);
     std::vector<LatLng> getCoordinates() const;
 
-    std::unique_ptr<mbgl::UnassociatedImage> getData() const;
+    const mbgl::UnassociatedImage& getData() const;
 
     void loadDescription(FileSource&) final;
 
@@ -34,7 +34,7 @@ private:
     std::string url;
     std::vector<LatLng> coords;
     std::unique_ptr<AsyncRequest> req;
-    std::unique_ptr<mbgl::UnassociatedImage> image;
+    mbgl::UnassociatedImage image;
 };
 
 } // namespace style
diff --git a/src/mbgl/util/tile_coordinate.hpp b/src/mbgl/util/tile_coordinate.hpp
index bcd1c8444f..e10899cc6d 100644
--- a/src/mbgl/util/tile_coordinate.hpp
+++ b/src/mbgl/util/tile_coordinate.hpp
@@ -44,6 +44,18 @@ public:
                         std::numeric_limits<int16_t>::max()))
         };
     }
+
+    static GeometryCoordinate toGeometryCoordinate(const LatLng& latLng) {
+        auto projectedPoint = Projection::project(latLng, 1) / double (util::tileSize);
+        return {
+            int16_t(util::clamp<int64_t>(projectedPoint.x * util::EXTENT,
+                                         std::numeric_limits<int16_t>::min(),
+                                         std::numeric_limits<int16_t>::max())),
+            int16_t(util::clamp<int64_t>(projectedPoint.y * util::EXTENT,
+                                         std::numeric_limits<int16_t>::min(),
+                                         std::numeric_limits<int16_t>::max()))
+        };
+    }
 };
 
 } // namespace mbgl