[core] Pass std::shared_ptr<UpdateParameters> to the render orchestrator

So that it can retain ownership of the given parameters.

9 files changed, 73 insertions, 72 deletions

diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp
index 7a1ddde1c1..91f2b6146c 100644
--- a/include/mbgl/renderer/renderer.hpp
+++ b/include/mbgl/renderer/renderer.hpp
@@ -31,7 +31,7 @@ public:
 
     void setObserver(RendererObserver*);
 
-    void render(const UpdateParameters&);
+    void render(const std::shared_ptr<UpdateParameters>&);
 
     // Feature queries
     std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions& options = {}) const;
diff --git a/platform/android/src/map_renderer.cpp b/platform/android/src/map_renderer.cpp
index 0c0e907f14..f5336e3dd8 100644
--- a/platform/android/src/map_renderer.cpp
+++ b/platform/android/src/map_renderer.cpp
@@ -143,7 +143,7 @@ void MapRenderer::render(JNIEnv&) {
         framebufferSizeChanged = false;
     }
 
-    renderer->render(*params);
+    renderer->render(params);
 
     // Deliver the snapshot if requested
     if (snapshotCallback) {
diff --git a/platform/darwin/src/MGLRendererFrontend.h b/platform/darwin/src/MGLRendererFrontend.h
index 1358f5fafa..e2b8260fd1 100644
--- a/platform/darwin/src/MGLRendererFrontend.h
+++ b/platform/darwin/src/MGLRendererFrontend.h
@@ -54,7 +54,7 @@ public:
         // Copy the shared pointer here so that the parameters aren't destroyed while `render(...)` is
         // still using them.
         auto updateParameters_ = updateParameters;
-        renderer->render(*updateParameters_);
+        renderer->render(updateParameters_);
     }
     
     mbgl::Renderer* getRenderer() {
diff --git a/platform/default/src/mbgl/gfx/headless_frontend.cpp b/platform/default/src/mbgl/gfx/headless_frontend.cpp
index 5235b2f408..996006bfe2 100644
--- a/platform/default/src/mbgl/gfx/headless_frontend.cpp
+++ b/platform/default/src/mbgl/gfx/headless_frontend.cpp
@@ -39,7 +39,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_,
               // Copy the shared pointer here so that the parameters aren't destroyed while `render(...)` is
               // still using them.
               auto updateParameters_ = updateParameters;
-              renderer->render(*updateParameters_);
+              renderer->render(updateParameters_);
 
               auto endTime = mbgl::util::MonotonicTimer::now();
               frameTime = (endTime - startTime).count();
diff --git a/platform/glfw/glfw_renderer_frontend.cpp b/platform/glfw/glfw_renderer_frontend.cpp
index b8478a49f8..46f1309901 100644
--- a/platform/glfw/glfw_renderer_frontend.cpp
+++ b/platform/glfw/glfw_renderer_frontend.cpp
@@ -38,7 +38,7 @@ void GLFWRendererFrontend::render() {
     // Copy the shared pointer here so that the parameters aren't destroyed while `render(...)` is
     // still using them.
     auto updateParameters_ = updateParameters;
-    renderer->render(*updateParameters_);
+    renderer->render(updateParameters_);
 }
 
 mbgl::Renderer* GLFWRendererFrontend::getRenderer() {
diff --git a/platform/qt/src/qmapboxgl_map_renderer.cpp b/platform/qt/src/qmapboxgl_map_renderer.cpp
index 8423470323..7c7f5ee151 100644
--- a/platform/qt/src/qmapboxgl_map_renderer.cpp
+++ b/platform/qt/src/qmapboxgl_map_renderer.cpp
@@ -84,7 +84,7 @@ void QMapboxGLMapRenderer::render()
     // The OpenGL implementation automatically enables the OpenGL context for us.
     mbgl::gfx::BackendScope scope(m_backend, mbgl::gfx::BackendScope::ScopeType::Implicit);
 
-    m_renderer->render(*params);
+    m_renderer->render(params);
 
     if (m_forceScheduler) {
         getScheduler()->processEvents();
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index aa32acc04a..239ad19876 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -135,51 +135,49 @@ void RenderOrchestrator::setObserver(RendererObserver* observer_) {
     observer = observer_ ? observer_ : &nullObserver();
 }
 
-std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdateParameters& updateParameters) {
-    const bool isMapModeContinuous = updateParameters.mode == MapMode::Continuous;
+std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(
+    const std::shared_ptr<UpdateParameters>& updateParameters) {
+    const bool isMapModeContinuous = updateParameters->mode == MapMode::Continuous;
     if (!isMapModeContinuous) {
         // Reset zoom history state.
         zoomHistory.first = true;
     }
 
     if (LayerManager::annotationsEnabled) {
-        updateParameters.annotationManager.updateData();
+        updateParameters->annotationManager.updateData();
     }
 
-    const bool zoomChanged = zoomHistory.update(updateParameters.transformState.getZoom(), updateParameters.timePoint);
+    const bool zoomChanged =
+        zoomHistory.update(updateParameters->transformState.getZoom(), updateParameters->timePoint);
 
-    const TransitionOptions transitionOptions = isMapModeContinuous ? updateParameters.transitionOptions : TransitionOptions();
+    const TransitionOptions transitionOptions =
+        isMapModeContinuous ? updateParameters->transitionOptions : TransitionOptions();
 
-    const TransitionParameters transitionParameters {
-        updateParameters.timePoint,
-        transitionOptions
-    };
+    const TransitionParameters transitionParameters{updateParameters->timePoint, transitionOptions};
 
-    const PropertyEvaluationParameters evaluationParameters {
+    const PropertyEvaluationParameters evaluationParameters{
         zoomHistory,
-        updateParameters.timePoint,
-        transitionOptions.duration.value_or(isMapModeContinuous ? util::DEFAULT_TRANSITION_DURATION : Duration::zero())
-    };
-
-    const TileParameters tileParameters {
-        updateParameters.pixelRatio,
-        updateParameters.debugOptions,
-        updateParameters.transformState,
-        updateParameters.fileSource,
-        updateParameters.mode,
-        updateParameters.annotationManager,
-        *imageManager,
-        *glyphManager,
-        updateParameters.prefetchZoomDelta
-    };
-
-    glyphManager->setURL(updateParameters.glyphURL);
+        updateParameters->timePoint,
+        transitionOptions.duration.value_or(isMapModeContinuous ? util::DEFAULT_TRANSITION_DURATION
+                                                                : Duration::zero())};
+
+    const TileParameters tileParameters{updateParameters->pixelRatio,
+                                        updateParameters->debugOptions,
+                                        updateParameters->transformState,
+                                        updateParameters->fileSource,
+                                        updateParameters->mode,
+                                        updateParameters->annotationManager,
+                                        *imageManager,
+                                        *glyphManager,
+                                        updateParameters->prefetchZoomDelta};
+
+    glyphManager->setURL(updateParameters->glyphURL);
 
     // Update light.
-    const bool lightChanged = renderLight.impl != updateParameters.light;
+    const bool lightChanged = renderLight.impl != updateParameters->light;
 
     if (lightChanged) {
-        renderLight.impl = updateParameters.light;
+        renderLight.impl = updateParameters->light;
         renderLight.transition(transitionParameters);
     }
 
@@ -187,9 +185,8 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         renderLight.evaluate(evaluationParameters);
     }
 
-
-    const ImageDifference imageDiff = diffImages(imageImpls, updateParameters.images);
-    imageImpls = updateParameters.images;
+    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();
@@ -214,10 +211,10 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
     }
 
     imageManager->notifyIfMissingImageAdded();
-    imageManager->setLoaded(updateParameters.spriteLoaded);
+    imageManager->setLoaded(updateParameters->spriteLoaded);
 
-    const LayerDifference layerDiff = diffLayers(layerImpls, updateParameters.layers);
-    layerImpls = updateParameters.layers;
+    const LayerDifference layerDiff = diffLayers(layerImpls, updateParameters->layers);
+    layerImpls = updateParameters->layers;
     const bool layersAddedOrRemoved = !layerDiff.added.empty() || !layerDiff.removed.empty();
 
     // Remove render layers for removed layers.
@@ -266,8 +263,8 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         }
     }
 
-    const SourceDifference sourceDiff = diffSources(sourceImpls, updateParameters.sources);
-    sourceImpls = updateParameters.sources;
+    const SourceDifference sourceDiff = diffSources(sourceImpls, updateParameters->sources);
+    sourceImpls = updateParameters->sources;
 
     // Remove render layers for removed sources.
     for (const auto& entry : sourceDiff.removed) {
@@ -280,15 +277,14 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         renderSource->setObserver(this);
         renderSources.emplace(entry.first, std::move(renderSource));
     }
-    transformState = updateParameters.transformState;
+    transformState = updateParameters->transformState;
 
     // Create parameters for the render tree.
-    auto renderTreeParameters = std::make_unique<RenderTreeParameters>(
-        updateParameters.transformState,
-        updateParameters.mode,
-        updateParameters.debugOptions,
-        updateParameters.timePoint,
-        renderLight.getEvaluated());
+    auto renderTreeParameters = std::make_unique<RenderTreeParameters>(updateParameters->transformState,
+                                                                       updateParameters->mode,
+                                                                       updateParameters->debugOptions,
+                                                                       updateParameters->timePoint,
+                                                                       renderLight.getEvaluated());
 
     std::set<LayerRenderItem> layerRenderItems;
     layersNeedPlacement.clear();
@@ -349,7 +345,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         filteredLayersForSource.clear();
     }
 
-    renderTreeParameters->loaded = updateParameters.styleLoaded && isLoaded();
+    renderTreeParameters->loaded = updateParameters->styleLoaded && isLoaded();
     if (!isMapModeContinuous && !renderTreeParameters->loaded) {
         return nullptr;
     }
@@ -357,14 +353,16 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
     // Prepare. Update all matrices and generate data that we should upload to the GPU.
     for (const auto& entry : renderSources) {
         if (entry.second->isEnabled()) {
-            entry.second->prepare({renderTreeParameters->transformParams, updateParameters.debugOptions, *imageManager});
+            entry.second->prepare(
+                {renderTreeParameters->transformParams, updateParameters->debugOptions, *imageManager});
         }
     }
 
     auto opaquePassCutOffEstimation = layerRenderItems.size();
     for (auto& renderItem : layerRenderItems) {
         RenderLayer& renderLayer = renderItem.layer;
-        renderLayer.prepare({renderItem.source, *imageManager, *patternAtlas, *lineAtlas, updateParameters.transformState});
+        renderLayer.prepare(
+            {renderItem.source, *imageManager, *patternAtlas, *lineAtlas, updateParameters->transformState});
         if (renderLayer.needsPlacement()) {
             layersNeedPlacement.emplace_back(renderLayer);
         }
@@ -380,7 +378,7 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
     if (isMapModeContinuous) {
         bool symbolBucketsAdded = false;
         for (auto it = layersNeedPlacement.crbegin(); it != layersNeedPlacement.crend(); ++it) {
-            auto result = crossTileSymbolIndex.addLayer(*it, updateParameters.transformState.getLatLng().longitude());
+            auto result = crossTileSymbolIndex.addLayer(*it, updateParameters->transformState.getLatLng().longitude());
             symbolBucketsAdded = symbolBucketsAdded || (result & CrossTileSymbolIndex::AddLayerResult::BucketsAdded);
             symbolBucketsChanged = symbolBucketsChanged || (result != CrossTileSymbolIndex::AddLayerResult::NoChanges);
         }
@@ -391,22 +389,24 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
         optional<Duration> maximumPlacementUpdatePeriod;
         if (symbolBucketsAdded) maximumPlacementUpdatePeriod = optional<Duration>(Milliseconds(30));
         renderTreeParameters->placementChanged = !placementController.placementIsRecent(
-            updateParameters.timePoint, updateParameters.transformState.getZoom(), maximumPlacementUpdatePeriod);
+            updateParameters->timePoint, updateParameters->transformState.getZoom(), maximumPlacementUpdatePeriod);
         symbolBucketsChanged |= renderTreeParameters->placementChanged;
 
         std::set<std::string> usedSymbolLayers;
         if (renderTreeParameters->placementChanged) {
-            Mutable<Placement> placement = makeMutable<Placement>(updateParameters.transformState,
-                                                                  updateParameters.mode,
-                                                                  updateParameters.transitionOptions,
-                                                                  updateParameters.crossSourceCollisions,
-                                                                  updateParameters.timePoint,
+            Mutable<Placement> placement = makeMutable<Placement>(updateParameters->transformState,
+                                                                  updateParameters->mode,
+                                                                  updateParameters->transitionOptions,
+                                                                  updateParameters->crossSourceCollisions,
+                                                                  updateParameters->timePoint,
                                                                   placementController.getPlacement());
 
             for (auto it = layersNeedPlacement.crbegin(); it != layersNeedPlacement.crend(); ++it) {
                 const RenderLayer& layer = *it;
                 usedSymbolLayers.insert(layer.getID());
-                placement->placeLayer(layer, renderTreeParameters->transformParams.projMatrix, updateParameters.debugOptions & MapDebugOptions::Collision);
+                placement->placeLayer(layer,
+                                      renderTreeParameters->transformParams.projMatrix,
+                                      updateParameters->debugOptions & MapDebugOptions::Collision);
             }
 
             placement->commit();
@@ -419,23 +419,23 @@ std::unique_ptr<RenderTree> RenderOrchestrator::createRenderTree(const UpdatePar
             placementController.setPlacementStale();
         }
         renderTreeParameters->symbolFadeChange =
-            placementController.getPlacement()->symbolFadeChange(updateParameters.timePoint);
-        renderTreeParameters->needsRepaint = hasTransitions(updateParameters.timePoint);
+            placementController.getPlacement()->symbolFadeChange(updateParameters->timePoint);
+        renderTreeParameters->needsRepaint = hasTransitions(updateParameters->timePoint);
     } else {
         crossTileSymbolIndex.reset();
         renderTreeParameters->placementChanged = symbolBucketsChanged = !layersNeedPlacement.empty();
         if (renderTreeParameters->placementChanged) {
-            Mutable<Placement> placement = makeMutable<Placement>(updateParameters.transformState,
-                                                                  updateParameters.mode,
-                                                                  updateParameters.transitionOptions,
-                                                                  updateParameters.crossSourceCollisions,
-                                                                  updateParameters.timePoint);
+            Mutable<Placement> placement = makeMutable<Placement>(updateParameters->transformState,
+                                                                  updateParameters->mode,
+                                                                  updateParameters->transitionOptions,
+                                                                  updateParameters->crossSourceCollisions,
+                                                                  updateParameters->timePoint);
             for (auto it = layersNeedPlacement.crbegin(); it != layersNeedPlacement.crend(); ++it) {
                 const RenderLayer& layer = *it;
-                crossTileSymbolIndex.addLayer(layer, updateParameters.transformState.getLatLng().longitude());
+                crossTileSymbolIndex.addLayer(layer, updateParameters->transformState.getLatLng().longitude());
                 placement->placeLayer(layer,
                                       renderTreeParameters->transformParams.projMatrix,
-                                      updateParameters.debugOptions & MapDebugOptions::Collision);
+                                      updateParameters->debugOptions & MapDebugOptions::Collision);
             }
             placement->commit();
             placementController.setPlacement(std::move(placement));
diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp
index c2b44c2792..4983538749 100644
--- a/src/mbgl/renderer/render_orchestrator.hpp
+++ b/src/mbgl/renderer/render_orchestrator.hpp
@@ -52,7 +52,7 @@ public:
     // TODO: Introduce RenderOrchestratorObserver.
     void setObserver(RendererObserver*);
 
-    std::unique_ptr<RenderTree> createRenderTree(const UpdateParameters&);
+    std::unique_ptr<RenderTree> createRenderTree(const std::shared_ptr<UpdateParameters>&);
 
     std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions&) const;
     std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions&) const;
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
index a74a21030e..5afbbbd47e 100644
--- a/src/mbgl/renderer/renderer.cpp
+++ b/src/mbgl/renderer/renderer.cpp
@@ -25,7 +25,8 @@ void Renderer::setObserver(RendererObserver* observer) {
     impl->orchestrator.setObserver(observer);
 }
 
-void Renderer::render(const UpdateParameters& updateParameters) {
+void Renderer::render(const std::shared_ptr<UpdateParameters>& updateParameters) {
+    assert(updateParameters);
     if (auto renderTree = impl->orchestrator.createRenderTree(updateParameters)) {
         renderTree->prepare();
         impl->render(*renderTree);