[core] make{Glyph,Image}Atlas only once for any number of symbol layers

src/mbgl/layout/symbol_layout.hpp

@@ -40,13 +40,6 @@ class SymbolLayout {
 
     bool hasSymbolInstances() const;
 
-    enum State {
-        Pending,  // Waiting for the necessary glyphs or icons to be available.
-        Placed    // The final positions have been determined, taking into account prior layers.
-    };
-
-    State state = Pending;
-
     std::map<std::string,
         std::pair<style::IconPaintProperties::PossiblyEvaluated, style::TextPaintProperties::PossiblyEvaluated>> layerPaintProperties;
 

src/mbgl/tile/geometry_tile_worker.cpp

@@ -144,14 +144,14 @@ void GeometryTileWorker::symbolDependenciesChanged() {
     try {
         switch (state) {
         case Idle:
-            if (hasPendingSymbolLayouts()) {
+            if (symbolLayoutsNeedPreparation) {
                 attemptPlacement();
                 coalesce();
             }
             break;
 
         case Coalescing:
-            if (hasPendingSymbolLayouts()) {
+            if (symbolLayoutsNeedPreparation) {
                 state = NeedPlacement;
             }
             break;
@@ -312,6 +312,7 @@ void GeometryTileWorker::redoLayout() {
             auto layout = leader.as<RenderSymbolLayer>()->createLayout(
                 parameters, group, std::move(geometryLayer), glyphDependencies, imageDependencies);
             symbolLayoutMap.emplace(leader.getID(), std::move(layout));
+            symbolLayoutsNeedPreparation = true;
         } else {
             const Filter& filter = leader.baseImpl->filter;
             const std::string& sourceLayerID = leader.baseImpl->sourceLayer;
@@ -359,16 +360,6 @@ void GeometryTileWorker::redoLayout() {
     attemptPlacement();
 }
 
-bool GeometryTileWorker::hasPendingSymbolLayouts() const {
-    for (const auto& symbolLayout : symbolLayouts) {
-        if (symbolLayout->state == SymbolLayout::Pending) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 bool GeometryTileWorker::hasPendingSymbolDependencies() const {
     for (auto& glyphDependency : pendingGlyphDependencies) {
         if (!glyphDependency.second.empty()) {
@@ -378,33 +369,39 @@ bool GeometryTileWorker::hasPendingSymbolDependencies() const {
     return !pendingImageDependencies.empty();
 }
 
-
 void GeometryTileWorker::attemptPlacement() {
     if (!data || !layers || !placementConfig || hasPendingSymbolDependencies()) {
         return;
     }
 
-    auto collisionTile = std::make_unique<CollisionTile>(*placementConfig);
-    std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
-
     optional<AlphaImage> glyphAtlasImage;
     optional<PremultipliedImage> iconAtlasImage;
 
-    for (auto& symbolLayout : symbolLayouts) {
-        if (obsolete) {
-            return;
-        }
+    if (symbolLayoutsNeedPreparation) {
+        GlyphAtlas glyphAtlas = makeGlyphAtlas(glyphMap);
+        ImageAtlas imageAtlas = makeImageAtlas(imageMap);
+
+        glyphAtlasImage = std::move(glyphAtlas.image);
+        iconAtlasImage = std::move(imageAtlas.image);
 
-        if (symbolLayout->state == SymbolLayout::Pending) {
-            GlyphAtlas glyphAtlas = makeGlyphAtlas(glyphMap);
-            ImageAtlas imageAtlas = makeImageAtlas(imageMap);
+        for (auto& symbolLayout : symbolLayouts) {
+            if (obsolete) {
+                return;
+            }
 
             symbolLayout->prepare(glyphMap, glyphAtlas.positions,
                                   imageMap, imageAtlas.positions);
-            symbolLayout->state = SymbolLayout::Placed;
+        }
+
+        symbolLayoutsNeedPreparation = false;
+    }
 
-            glyphAtlasImage = std::move(glyphAtlas.image);
-            iconAtlasImage = std::move(imageAtlas.image);
+    auto collisionTile = std::make_unique<CollisionTile>(*placementConfig);
+    std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+
+    for (auto& symbolLayout : symbolLayouts) {
+        if (obsolete) {
+            return;
         }
 
         if (!symbolLayout->hasSymbolInstances()) {

src/mbgl/tile/geometry_tile_worker.hpp

@@ -52,7 +52,6 @@ class GeometryTileWorker {
 
     void symbolDependenciesChanged();
     bool hasPendingSymbolDependencies() const;
-    bool hasPendingSymbolLayouts() const;
 
     ActorRef<GeometryTileWorker> self;
     ActorRef<GeometryTile> parent;
@@ -77,6 +76,7 @@ class GeometryTileWorker {
     optional<std::unique_ptr<const GeometryTileData>> data;
     optional<PlacementConfig> placementConfig;
 
+    bool symbolLayoutsNeedPreparation = false;
     std::vector<std::unique_ptr<SymbolLayout>> symbolLayouts;
     GlyphDependencies pendingGlyphDependencies;
     ImageDependencies pendingImageDependencies;