1 files changed, 66 insertions, 59 deletions

diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 471536cf40..7144a2dcee 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -16,6 +16,7 @@
 #include <mbgl/renderer/query.hpp>
 #include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/renderer/image_manager.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/gl/debugging.hpp>
 #include <mbgl/geometry/line_atlas.hpp>
 #include <mbgl/style/source_impl.hpp>
@@ -82,6 +83,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     if (!imageManager) {
         imageManager = std::make_unique<ImageManager>();
+        imageManager->setObserver(this);
     }
 
     if (updateParameters.mode != MapMode::Continuous) {
@@ -142,6 +144,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     const ImageDifference imageDiff = diffImages(imageImpls, updateParameters.images);
     imageImpls = updateParameters.images;
 
+    // Only trigger tile reparse for changed images. Changed images only need a relayout when they have a different size.
+    bool hasImageDiff = !imageDiff.removed.empty();
+
     // Remove removed images from sprite atlas.
     for (const auto& entry : imageDiff.removed) {
         imageManager->removeImage(entry.first);
@@ -154,9 +159,10 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     // Update changed images.
     for (const auto& entry : imageDiff.changed) {
-        imageManager->updateImage(entry.second.after);
+        hasImageDiff = imageManager->updateImage(entry.second.after) || hasImageDiff;
     }
 
+    imageManager->notifyIfMissingImageAdded();
     imageManager->setLoaded(updateParameters.spriteLoaded);
 
 
@@ -214,8 +220,6 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         renderSources.emplace(entry.first, std::move(renderSource));
     }
 
-    const bool hasImageDiff = !(imageDiff.added.empty() && imageDiff.removed.empty() && imageDiff.changed.empty());
-
     // Update all sources.
     for (const auto& source : *sourceImpls) {
         std::vector<Immutable<Layer::Impl>> filteredLayers;
@@ -262,7 +266,8 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         renderLight.getEvaluated(),
         *staticData,
         *imageManager,
-        *lineAtlas
+        *lineAtlas,
+        placement->getVariableOffsets()
     };
 
     bool loaded = updateParameters.styleLoaded && isLoaded();
@@ -278,8 +283,11 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     backend.updateAssumedState();
 
+    // TODO: remove cast
+    gl::Context& glContext = reinterpret_cast<gl::Context&>(parameters.context);
+
     if (parameters.contextMode == GLContextMode::Shared) {
-        parameters.context.setDirtyState();
+        glContext.setDirtyState();
     }
 
     Color backgroundColor;
@@ -292,6 +300,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     };
 
     std::vector<RenderItem> order;
+    std::vector<const RenderLayerSymbolInterface*> renderItemsWithSymbols;
 
     for (auto& layerImpl : *layerImpls) {
         RenderLayer* layer = getRenderLayer(layerImpl->id);
@@ -326,6 +335,10 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
         layer->setRenderTiles(source->getRenderTiles(), parameters.state);
         order.emplace_back(*layer, source);
+
+        if (const RenderLayerSymbolInterface* symbolLayer = layer->getSymbolInterface()) {
+            renderItemsWithSymbols.push_back(symbolLayer);
+        }
     }
 
     {
@@ -334,32 +347,28 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
             crossTileSymbolIndex.reset();
         }
 
-        std::vector<RenderItem> renderItemsWithSymbols;
-        std::copy_if(order.rbegin(), order.rend(), std::back_inserter(renderItemsWithSymbols),
-                [](const auto& item) { return item.layer.getSymbolInterface() != nullptr; });
-
         bool symbolBucketsChanged = false;
         const bool placementChanged = !placement->stillRecent(parameters.timePoint);
-        std::unique_ptr<Placement> newPlacement;
         std::set<std::string> usedSymbolLayers;
 
         if (placementChanged) {
-            newPlacement = std::make_unique<Placement>(parameters.state, parameters.mapMode, updateParameters.transitionOptions, updateParameters.crossSourceCollisions);
+            placement = std::make_unique<Placement>(parameters.state, parameters.mapMode, updateParameters.transitionOptions, updateParameters.crossSourceCollisions, std::move(placement));
         }
 
-        for (const auto& item : renderItemsWithSymbols) {
-            if (crossTileSymbolIndex.addLayer(*item.layer.getSymbolInterface(), parameters.state.getLatLng().longitude())) symbolBucketsChanged = true;
+        for (auto it = renderItemsWithSymbols.rbegin(); it != renderItemsWithSymbols.rend(); ++it) {
+            const RenderLayerSymbolInterface *symbolLayer = *it;
+            if (crossTileSymbolIndex.addLayer(*symbolLayer, parameters.state.getLatLng().longitude())) symbolBucketsChanged = true;
 
-            if (newPlacement) {
-                usedSymbolLayers.insert(item.layer.getID());
-                newPlacement->placeLayer(*item.layer.getSymbolInterface(), parameters.projMatrix, parameters.debugOptions & MapDebugOptions::Collision);
+            if (placementChanged) {
+                usedSymbolLayers.insert(symbolLayer->layerID());
+                placement->placeLayer(*symbolLayer, parameters.projMatrix, parameters.debugOptions & MapDebugOptions::Collision);
             }
         }
 
-        if (newPlacement) {
-            newPlacement->commit(*placement, parameters.timePoint);
+        if (placementChanged) {
+            placement->commit(parameters.timePoint);
             crossTileSymbolIndex.pruneUnusedLayers(usedSymbolLayers);
-            placement = std::move(newPlacement);
+            parameters.variableOffsets = placement->getVariableOffsets();
             updateFadingTiles();
         } else {
             placement->setStale();
@@ -368,8 +377,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         parameters.symbolFadeChange = placement->symbolFadeChange(parameters.timePoint);
 
         if (placementChanged || symbolBucketsChanged) {
-            for (const auto& item : renderItemsWithSymbols) {
-                placement->updateLayerOpacities(*item.layer.getSymbolInterface());
+            for (auto it = renderItemsWithSymbols.rbegin(); it != renderItemsWithSymbols.rend(); ++it) {
+                const RenderLayerSymbolInterface *symbolLayer = *it;
+                placement->updateLayerOpacities(*symbolLayer);
             }
         }
     }
@@ -402,7 +412,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         if (!parameters.staticData.depthRenderbuffer ||
             parameters.staticData.depthRenderbuffer->size != parameters.staticData.backendSize) {
             parameters.staticData.depthRenderbuffer =
-                parameters.context.createRenderbuffer<gl::RenderbufferType::DepthComponent>(parameters.staticData.backendSize);
+                glContext.createRenderbuffer<gl::RenderbufferType::DepthComponent>(parameters.staticData.backendSize);
         }
         parameters.staticData.depthRenderbuffer->shouldClear(true);
 
@@ -425,11 +435,11 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         MBGL_DEBUG_GROUP(parameters.context, "clear");
         parameters.backend.bind();
         if (parameters.debugOptions & MapDebugOptions::Overdraw) {
-            parameters.context.clear(Color::black(), ClearDepth::Default, ClearStencil::Default);
+            glContext.clear(Color::black(), ClearDepth::Default, ClearStencil::Default);
         } else if (parameters.contextMode == GLContextMode::Shared) {
-            parameters.context.clear({}, ClearDepth::Default, ClearStencil::Default);
+            glContext.clear({}, ClearDepth::Default, ClearStencil::Default);
         } else {
-            parameters.context.clear(backgroundColor, ClearDepth::Default, ClearStencil::Default);
+            glContext.clear(backgroundColor, ClearDepth::Default, ClearStencil::Default);
         }
     }
 
@@ -462,7 +472,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                 parameters.staticData.tileTriangleSegments,
                 program.computeAllUniformValues(
                     ClippingMaskProgram::LayoutUniformValues {
-                        uniforms::u_matrix::Value( parameters.matrixForTile(clipID.first) ),
+                        uniforms::matrix::Value( parameters.matrixForTile(clipID.first) ),
                     },
                     paintAttributeData,
                     properties,
@@ -482,17 +492,17 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 #if not MBGL_USE_GLES2 and not defined(NDEBUG)
     // Render tile clip boundaries, using stencil buffer to calculate fill color.
     if (parameters.debugOptions & MapDebugOptions::StencilClip) {
-        parameters.context.setStencilMode(gfx::StencilMode::disabled());
-        parameters.context.setDepthMode(gfx::DepthMode::disabled());
-        parameters.context.setColorMode(gfx::ColorMode::unblended());
-        parameters.context.program = 0;
+        glContext.setStencilMode(gfx::StencilMode::disabled());
+        glContext.setDepthMode(gfx::DepthMode::disabled());
+        glContext.setColorMode(gfx::ColorMode::unblended());
+        glContext.program = 0;
 
         // Reset the value in case someone else changed it, or it's dirty.
-        parameters.context.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
+        glContext.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
 
         // Read the stencil buffer
-        const auto viewport = parameters.context.viewport.getCurrentValue();
-        auto image = parameters.context.readFramebuffer<AlphaImage, gfx::TexturePixelType::Stencil>(viewport.size, false);
+        const auto viewport = glContext.viewport.getCurrentValue();
+        auto image = glContext.readFramebuffer<AlphaImage, gfx::TexturePixelType::Stencil>(viewport.size, false);
 
         // Scale the Stencil buffer to cover the entire color space.
         auto it = image.data.get();
@@ -502,9 +512,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
             *it *= factor;
         }
 
-        parameters.context.pixelZoom = { 1, 1 };
-        parameters.context.rasterPos = { -1, -1, 0, 1 };
-        parameters.context.drawPixels(image);
+        glContext.pixelZoom = { 1, 1 };
+        glContext.rasterPos = { -1, -1, 0, 1 };
+        glContext.drawPixels(image);
 
         return;
     }
@@ -565,39 +575,26 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 #if not MBGL_USE_GLES2 and not defined(NDEBUG)
     // Render the depth buffer.
     if (parameters.debugOptions & MapDebugOptions::DepthBuffer) {
-        parameters.context.setStencilMode(gfx::StencilMode::disabled());
-        parameters.context.setDepthMode(gfx::DepthMode::disabled());
-        parameters.context.setColorMode(gfx::ColorMode::unblended());
-        parameters.context.program = 0;
+        glContext.setStencilMode(gfx::StencilMode::disabled());
+        glContext.setDepthMode(gfx::DepthMode::disabled());
+        glContext.setColorMode(gfx::ColorMode::unblended());
+        glContext.program = 0;
 
         // Scales the values in the depth buffer so that they cover the entire grayscale range. This
         // makes it easier to spot tiny differences.
         const float base = 1.0f / (1.0f - parameters.depthRangeSize);
-        parameters.context.pixelTransferDepth = { base, 1.0f - base };
+        glContext.pixelTransferDepth = { base, 1.0f - base };
 
         // Read the stencil buffer
-        auto viewport = parameters.context.viewport.getCurrentValue();
-        auto image = parameters.context.readFramebuffer<AlphaImage, gfx::TexturePixelType::Depth>(viewport.size, false);
+        auto viewport = glContext.viewport.getCurrentValue();
+        auto image = glContext.readFramebuffer<AlphaImage, gfx::TexturePixelType::Depth>(viewport.size, false);
 
-        parameters.context.pixelZoom = { 1, 1 };
-        parameters.context.rasterPos = { -1, -1, 0, 1 };
-        parameters.context.drawPixels(image);
+        glContext.pixelZoom = { 1, 1 };
+        glContext.rasterPos = { -1, -1, 0, 1 };
+        glContext.drawPixels(image);
     }
 #endif
 
-    // TODO: Find a better way to unbind VAOs after we're done with them without introducing
-    // unnecessary bind(0)/bind(N) sequences.
-    {
-        MBGL_DEBUG_GROUP(parameters.context, "cleanup");
-
-        parameters.context.activeTextureUnit = 1;
-        parameters.context.texture[1] = 0;
-        parameters.context.activeTextureUnit = 0;
-        parameters.context.texture[0] = 0;
-
-        parameters.context.bindVertexArray = 0;
-    }
-
     observer->onDidFinishRenderingFrame(
         loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
         updateParameters.mode == MapMode::Continuous && hasTransitions(parameters.timePoint)
@@ -614,6 +611,12 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     parameters.context.performCleanup();
 }
 
+void  Renderer::Impl::flush() {
+    assert(BackendScope::exists());
+
+    backend.getContext().flush();
+}
+
 std::vector<Feature> Renderer::Impl::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options) const {
     std::vector<const RenderLayer*> layers;
     if (options.layerIDs) {
@@ -837,4 +840,8 @@ void Renderer::Impl::onTileChanged(RenderSource&, const OverscaledTileID&) {
     observer->onInvalidate();
 }
 
+void Renderer::Impl::onStyleImageMissing(const std::string& id, std::function<void()> done) {
+    observer->onStyleImageMissing(id, std::move(done));
+}
+
 } // namespace mbgl