partially do Placement asyncupstream/start-collision-async

5 files changed, 87 insertions, 47 deletions

diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index ebcf93f2b1..fbed45c25e 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -8,6 +8,17 @@ namespace mbgl {
 
 using namespace style;
 
+SymbolBucket::Core::Core(
+        std::vector<SymbolInstance>&& symbolInstances_,
+        style::SymbolLayoutProperties::PossiblyEvaluated layout_,
+        std::unique_ptr<SymbolSizeBinder> textSizeBinder_,
+        std::unique_ptr<SymbolSizeBinder> iconSizeBinder_) :
+    symbolInstances(std::move(symbolInstances_)),
+    layout(std::move(layout_)),
+    textSizeBinder(std::move(textSizeBinder_)),
+    iconSizeBinder(std::move(iconSizeBinder_))
+    {}
+
 SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layout_,
                            const std::map<std::string, std::pair<
                                style::IconPaintProperties::PossiblyEvaluated,
@@ -18,14 +29,16 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
                            bool sdfIcons_,
                            bool iconsNeedLinear_,
                            bool sortFeaturesByY_,
-                           const std::vector<SymbolInstance>&& symbolInstances_)
-    : layout(std::move(layout_)),
-      sdfIcons(sdfIcons_),
+                           std::vector<SymbolInstance>&& symbolInstances_)
+    : sdfIcons(sdfIcons_),
       iconsNeedLinear(iconsNeedLinear_ || iconSize.isDataDriven() || !iconSize.isZoomConstant()),
       sortFeaturesByY(sortFeaturesByY_),
-      symbolInstances(std::move(symbolInstances_)),
-      textSizeBinder(SymbolSizeBinder::create(zoom, textSize, TextSize::defaultValue())),
-      iconSizeBinder(SymbolSizeBinder::create(zoom, iconSize, IconSize::defaultValue())) {
+      mutableCore(makeMutable<Core>(
+                  std::move(symbolInstances_),
+                  std::move(layout_),
+                  SymbolSizeBinder::create(zoom, textSize, TextSize::defaultValue()),
+                  SymbolSizeBinder::create(zoom, iconSize, IconSize::defaultValue())
+                  )) {
     
     for (const auto& pair : layerPaintProperties) {
         paintPropertyBinders.emplace(
@@ -177,6 +190,10 @@ void SymbolBucket::sortFeatures(const float angle) {
     // The index array buffer is rewritten to reference the (unchanged) vertices in the
     // sorted order.
 
+    auto& symbolInstances = (*core)->symbolInstances;
+    auto& placedTextSymbols = (*core)->placedTextSymbols;
+    auto& placedIconSymbols = (*core)->placedIconSymbols;
+
     // To avoid sorting the actual symbolInstance array we sort an array of indexes.
     std::vector<size_t> symbolInstanceIndexes;
     for (size_t i = 0; i < symbolInstances.size(); i++) {
@@ -186,9 +203,9 @@ void SymbolBucket::sortFeatures(const float angle) {
     const float sin = std::sin(angle);
     const float cos = std::cos(angle);
 
-    std::sort(symbolInstanceIndexes.begin(), symbolInstanceIndexes.end(), [sin, cos, this](size_t &aIndex, size_t &bIndex) {
-        const SymbolInstance& a = symbolInstances[aIndex];
-        const SymbolInstance& b = symbolInstances[bIndex];
+    std::sort(symbolInstanceIndexes.begin(), symbolInstanceIndexes.end(), [sin, cos, symbolInstances](size_t &aIndex, size_t &bIndex) {
+        const SymbolInstance& a = symbolInstances.at(aIndex);
+        const SymbolInstance& b = symbolInstances.at(bIndex);
         const int32_t aRotated = sin * a.anchor.point.x + cos * a.anchor.point.y;
         const int32_t bRotated = sin * b.anchor.point.x + cos * b.anchor.point.y;
         return aRotated != bRotated ?
@@ -200,16 +217,16 @@ void SymbolBucket::sortFeatures(const float angle) {
     icon.triangles.clear();
 
     for (auto i : symbolInstanceIndexes) {
-        const SymbolInstance& symbolInstance = symbolInstances[i];
+        const SymbolInstance& symbolInstance = symbolInstances.at(i);
 
         if (symbolInstance.placedTextIndex) {
-            addPlacedSymbol(text.triangles, text.placedSymbols[*symbolInstance.placedTextIndex]);
+            addPlacedSymbol(text.triangles, placedTextSymbols[*symbolInstance.placedTextIndex]);
         }
         if (symbolInstance.placedVerticalTextIndex) {
-            addPlacedSymbol(text.triangles, text.placedSymbols[*symbolInstance.placedVerticalTextIndex]);
+            addPlacedSymbol(text.triangles, placedTextSymbols[*symbolInstance.placedVerticalTextIndex]);
         }
         if (symbolInstance.placedIconIndex) {
-            addPlacedSymbol(icon.triangles, icon.placedSymbols[*symbolInstance.placedIconIndex]);
+            addPlacedSymbol(icon.triangles, placedIconSymbols[*symbolInstance.placedIconIndex]);
         }
     }
 }
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index 4abea90508..f2f3f6197c 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -21,7 +21,7 @@ public:
     PlacedSymbol(Point<float> anchorPoint_, uint16_t segment_, float lowerSize_, float upperSize_,
             std::array<float, 2> lineOffset_, WritingModeType writingModes_, GeometryCoordinates line_, std::vector<float> tileDistances_) :
         anchorPoint(anchorPoint_), segment(segment_), lowerSize(lowerSize_), upperSize(upperSize_),
-        lineOffset(lineOffset_), writingModes(writingModes_), line(std::move(line_)), tileDistances(std::move(tileDistances_)), hidden(false), vertexStartIndex(0)
+        lineOffset(lineOffset_), writingModes(writingModes_), line(std::move(line_)), tileDistances(std::move(tileDistances_)), vertexStartIndex(0)
     {
     }
     Point<float> anchorPoint;
@@ -33,7 +33,6 @@ public:
     GeometryCoordinates line;
     std::vector<float> tileDistances;
     std::vector<float> glyphOffsets;
-    bool hidden;
     size_t vertexStartIndex;
 };
 
@@ -47,7 +46,7 @@ public:
                  bool sdfIcons,
                  bool iconsNeedLinear,
                  bool sortFeaturesByY,
-                 const std::vector<SymbolInstance>&&);
+                 std::vector<SymbolInstance>&&);
 
     void upload(gl::Context&) override;
     bool hasData() const override;
@@ -59,7 +58,6 @@ public:
     void updateOpacity();
     void sortFeatures(const float angle);
 
-    const style::SymbolLayoutProperties::PossiblyEvaluated layout;
     const bool sdfIcons;
     const bool iconsNeedLinear;
     const bool sortFeaturesByY;
@@ -71,21 +69,35 @@ public:
     bool dynamicUploaded = false;
     bool sortUploaded = false;
 
-    std::vector<SymbolInstance> symbolInstances;
+    std::unique_ptr<Immutable<std::vector<uint32_t>>> symbolCrossTileIDs;
+
+    class Core {
+        public:
+        Core(std::vector<SymbolInstance>&&, style::SymbolLayoutProperties::PossiblyEvaluated, std::unique_ptr<SymbolSizeBinder>, std::unique_ptr<SymbolSizeBinder>);
+        std::vector<SymbolInstance> symbolInstances;
+        const style::SymbolLayoutProperties::PossiblyEvaluated layout;
+        const std::unique_ptr<SymbolSizeBinder> textSizeBinder;
+        const std::unique_ptr<SymbolSizeBinder> iconSizeBinder;
+        std::vector<PlacedSymbol> placedTextSymbols;
+        std::vector<PlacedSymbol> placedIconSymbols;
+        bool hasTextData;
+        bool hasIconData;
+    };
+
+    Mutable<Core> mutableCore;
+    std::unique_ptr<Immutable<Core>> core;
 
     std::map<std::string, std::pair<
         SymbolIconProgram::PaintPropertyBinders,
         SymbolSDFTextProgram::PaintPropertyBinders>> paintPropertyBinders;
     
-    std::unique_ptr<SymbolSizeBinder> textSizeBinder;
-
     struct TextBuffer {
         gl::VertexVector<SymbolLayoutVertex> vertices;
         gl::VertexVector<SymbolDynamicLayoutAttributes::Vertex> dynamicVertices;
         gl::VertexVector<SymbolOpacityAttributes::Vertex> opacityVertices;
         gl::IndexVector<gl::Triangles> triangles;
         SegmentVector<SymbolTextAttributes> segments;
-        std::vector<PlacedSymbol> placedSymbols;
+        std::vector<bool> placedSymbolVisibility;
 
         optional<gl::VertexBuffer<SymbolLayoutVertex>> vertexBuffer;
         optional<gl::VertexBuffer<SymbolDynamicLayoutAttributes::Vertex>> dynamicVertexBuffer;
@@ -93,15 +105,13 @@ public:
         optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
     } text;
     
-    std::unique_ptr<SymbolSizeBinder> iconSizeBinder;
-    
     struct IconBuffer {
         gl::VertexVector<SymbolLayoutVertex> vertices;
         gl::VertexVector<SymbolDynamicLayoutAttributes::Vertex> dynamicVertices;
         gl::VertexVector<SymbolOpacityAttributes::Vertex> opacityVertices;
         gl::IndexVector<gl::Triangles> triangles;
         SegmentVector<SymbolIconAttributes> segments;
-        std::vector<PlacedSymbol> placedSymbols;
+        std::vector<bool> placedSymbolVisibility;
         PremultipliedImage atlasImage;
 
         optional<gl::VertexBuffer<SymbolLayoutVertex>> vertexBuffer;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index e194c9c857..9a3aceed77 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -78,7 +78,8 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
         assert(dynamic_cast<SymbolBucket*>(tile.tile.getBucket(*baseImpl)));
         SymbolBucket& bucket = *reinterpret_cast<SymbolBucket*>(tile.tile.getBucket(*baseImpl));
 
-        const auto& layout = bucket.layout;
+        const auto& core = **bucket.core;
+        const auto& layout = core.layout;
 
         auto draw = [&] (auto& program,
                          auto&& uniformValues,
@@ -127,11 +128,12 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             if (alongLine) {
                 reprojectLineLabels(bucket.icon.dynamicVertices,
-                                    bucket.icon.placedSymbols,
+                                    core.placedIconSymbols,
+                                    bucket.icon.placedSymbolVisibility,
                                     tile.matrix,
                                     values,
                                     tile,
-                                    *bucket.iconSizeBinder,
+                                    *core.iconSizeBinder,
                                     parameters.state);
 
                 parameters.context.updateVertexBuffer(*bucket.icon.dynamicVertexBuffer, std::move(bucket.icon.dynamicVertices));
@@ -151,7 +153,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                     draw(parameters.programs.symbolIconSDF,
                          SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                          bucket.icon,
-                         bucket.iconSizeBinder,
+                         core.iconSizeBinder,
                          values,
                          bucket.paintPropertyBinders.at(getID()).first,
                          paintPropertyValues);
@@ -161,7 +163,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                     draw(parameters.programs.symbolIconSDF,
                          SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                          bucket.icon,
-                         bucket.iconSizeBinder,
+                         core.iconSizeBinder,
                          values,
                          bucket.paintPropertyBinders.at(getID()).first,
                          paintPropertyValues);
@@ -170,7 +172,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 draw(parameters.programs.symbolIcon,
                      SymbolIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange),
                      bucket.icon,
-                     bucket.iconSizeBinder,
+                     core.iconSizeBinder,
                      values,
                      bucket.paintPropertyBinders.at(getID()).first,
                      paintPropertyValues);
@@ -188,11 +190,12 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             if (alongLine) {
                 reprojectLineLabels(bucket.text.dynamicVertices,
-                                    bucket.text.placedSymbols,
+                                    core.placedTextSymbols,
+                                    bucket.text.placedSymbolVisibility,
                                     tile.matrix,
                                     values,
                                     tile,
-                                    *bucket.textSizeBinder,
+                                    *core.textSizeBinder,
                                     parameters.state);
 
                 parameters.context.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices));
@@ -204,7 +207,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 draw(parameters.programs.symbolGlyph,
                      SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                      bucket.text,
-                     bucket.textSizeBinder,
+                     core.textSizeBinder,
                      values,
                      bucket.paintPropertyBinders.at(getID()).second,
                      paintPropertyValues);
@@ -214,7 +217,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 draw(parameters.programs.symbolGlyph,
                      SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                      bucket.text,
-                     bucket.textSizeBinder,
+                     core.textSizeBinder,
                      values,
                      bucket.paintPropertyBinders.at(getID()).second,
                      paintPropertyValues);
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index af0c491e15..ddd5718601 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -59,7 +59,7 @@ Renderer::Impl::Impl(RendererBackend& backend_,
     , layerImpls(makeMutable<std::vector<Immutable<style::Layer::Impl>>>())
     , renderLight(makeMutable<Light::Impl>())
     , crossTileSymbolIndex(std::make_unique<CrossTileSymbolIndex>())
-    , placement(std::make_unique<Placement>(TransformState{}, MapMode::Still)) {
+    , placement(std::make_unique<Placement>(TransformState{}, MapMode::Still, mat4(), false, scheduler_)) {
     glyphManager->setObserver(this);
 }
 
@@ -376,21 +376,30 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         }
     }
 
-    bool placementChanged = false;
     if (!placement->stillRecent(parameters.timePoint)) {
-        auto newPlacement = std::make_unique<Placement>(parameters.state, parameters.mapMode);
-        for (auto it = order.rbegin(); it != order.rend(); ++it) {
-            if (it->layer.is<RenderSymbolLayer>()) {
-                newPlacement->placeLayer(*it->layer.as<RenderSymbolLayer>(), parameters.projMatrix, parameters.debugOptions & MapDebugOptions::Collision);
+        if (!placementInProgress) {
+            placementInProgress = std::make_unique<Placement>(parameters.state, parameters.mapMode, parameters.projMatrix, parameters.debugOptions & MapDebugOptions::Collision, scheduler);
+            for (auto it = order.rbegin(); it != order.rend(); ++it) {
+                if (it->layer.is<RenderSymbolLayer>()) {
+                    placementInProgress->addLayer(*it->layer.as<RenderSymbolLayer>());
+                }
             }
+            placementInProgress->place();
         }
+    }
 
-        placementChanged = newPlacement->commit(*placement, parameters.timePoint);
-        if (placementChanged || symbolBucketsChanged) {
-            placement = std::move(newPlacement);
+    bool placementChanged = false;
+    if (placementInProgress) {
+        if (placementInProgress->isReady()) {
+            placementChanged = placementInProgress->commit(*placement, parameters.timePoint);
+            if (placementChanged || symbolBucketsChanged) {
+                placement = std::move(placementInProgress);
+                placement->setStale();
+            } else {
+                placement->setRecent(parameters.timePoint);
+                placementInProgress.reset();
+            }
         }
-
-        placement->setRecent(parameters.timePoint);
     } else {
         placement->setStale();
     }
@@ -654,7 +663,7 @@ std::vector<Feature> Renderer::Impl::queryRenderedFeatures(const ScreenLineStrin
     std::unordered_map<std::string, std::vector<Feature>> resultsByLayer;
     for (const auto& sourceID : sourceIDs) {
         if (RenderSource* renderSource = getRenderSource(sourceID)) {
-            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, layers, options, placement->collisionIndex);
+            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, layers, options, placement->result->collisionIndex);
             std::move(sourceResults.begin(), sourceResults.end(), std::inserter(resultsByLayer, resultsByLayer.begin()));
         }
     }
@@ -730,7 +739,7 @@ bool Renderer::Impl::hasTransitions(TimePoint timePoint) const {
         }
     }
 
-    if (placement->hasTransitions(timePoint)) {
+    if (placement->hasTransitions(timePoint) || placementInProgress) {
         return true;
     }
 
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
index dc19e84995..8e98c63497 100644
--- a/src/mbgl/renderer/renderer_impl.hpp
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -107,6 +107,7 @@ private:
 
     std::unique_ptr<CrossTileSymbolIndex> crossTileSymbolIndex;
     std::unique_ptr<Placement> placement;
+    std::unique_ptr<Placement> placementInProgress;
 
     bool contextLost = false;
 };